SONAR-20640 Make almSetting optional on ALM import endpoints

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/ImportHelperIT.java

 
 import org.junit.Rule;
 import org.junit.Test;
+import org.sonar.api.impl.ws.SimpleGetRequest;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.utils.System2;
 import org.sonar.db.DbTester;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.component.ProjectTesting;
 import org.sonar.db.project.ProjectDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubAlmSettingDto;
+import static org.sonar.server.almintegration.ws.ImportHelper.PARAM_ALM_SETTING;
 import static org.sonarqube.ws.Projects.CreateWsResponse;
 
 public class ImportHelperIT {
 
-  private static final AlmSettingDto ALM_SETTING_WITH_WEBHOOK_SECRET = newGithubAlmSettingDto().setWebhookSecret("webhook_secret");
+  // We use a GitHub ALM just because we have to use one. Tests are not specific to GitHub.
+  private static final ALM GITHUB_ALM = ALM.GITHUB;
   private final System2 system2 = System2.INSTANCE;
   private final ProjectDto projectDto = ProjectTesting.newPublicProjectDto();
-  private final Request request = mock(Request.class);
+  private final Request emptyRequest = new SimpleGetRequest();
 
   @Rule
   public final DbTester db = DbTester.create(system2);
   private final ImportHelper underTest = new ImportHelper(db.getDbClient(), userSession);
 
   @Test
-  public void it_throws_exception_when_provisioning_project_without_permission() {
-    assertThatThrownBy(() -> underTest.checkProvisionProjectPermission())
+  public void checkProvisionProjectPermission_whenNoPermissions_shouldThrow() {
+    assertThatThrownBy(underTest::checkProvisionProjectPermission)
       .isInstanceOf(UnauthorizedException.class)
       .hasMessage("Authentication is required");
   }
 
   @Test
-  public void it_throws_exception_on_get_alm_setting_when_key_is_empty() {
-    assertThatThrownBy(() -> underTest.getAlmSetting(request))
-      .isInstanceOf(NotFoundException.class);
+  public void getAlmConfig_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    assertThatThrownBy(() -> underTest.getAlmSettingDtoForAlm(emptyRequest, GITHUB_ALM))
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no GITHUB configuration for DevOps Platform. Please add one.");
   }
 
   @Test
-  public void it_throws_exception_on_get_alm_setting_when_key_is_not_found() {
-    when(request.mandatoryParam(ImportHelper.PARAM_ALM_SETTING)).thenReturn("key");
-    assertThatThrownBy(() -> underTest.getAlmSetting(request))
-      .isInstanceOf(NotFoundException.class)
-      .hasMessage("DevOps Platform Setting 'key' not found");
+  public void getAlmConfig_whenNoAlmSettingKeyAndOnlyOneConfig_shouldReturnConfig() {
+    AlmSettingDto githubAlmSettingDto = db.almSettings().insertGitHubAlmSetting();
+
+    AlmSettingDto almSettingDto = underTest.getAlmSettingDtoForAlm(emptyRequest, GITHUB_ALM);
+
+    assertThat(almSettingDto).usingRecursiveComparison().isEqualTo(githubAlmSettingDto);
   }
 
   @Test
-  public void it_throws_exception_when_user_uuid_is_null() {
-    assertThatThrownBy(() -> underTest.getUserUuid())
-      .isInstanceOf(NullPointerException.class)
-      .hasMessage("User UUID cannot be null");
+  public void getAlmConfig_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    db.almSettings().insertGitHubAlmSetting();
+    db.almSettings().insertGitHubAlmSetting();
+
+    assertThatThrownBy(() -> underTest.getAlmSettingDtoForAlm(emptyRequest, GITHUB_ALM))
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
   }
 
   @Test
-  public void it_returns_create_response() {
-    CreateWsResponse response = ImportHelper.toCreateResponse(projectDto);
-    CreateWsResponse.Project project = response.getProject();
+  public void getAlmConfig_whenAlmSettingKeyProvidedButDoesNotExist_shouldThrow() {
+    Request request = new SimpleGetRequest()
+      .setParam(PARAM_ALM_SETTING, "key");
 
-    assertThat(project).extracting(CreateWsResponse.Project::getKey, CreateWsResponse.Project::getName,
-        CreateWsResponse.Project::getQualifier)
-      .containsExactly(projectDto.getKey(), projectDto.getName(), projectDto.getQualifier());
+    assertThatThrownBy(() -> underTest.getAlmSettingDtoForAlm(request, GITHUB_ALM))
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'key' not found.");
   }
 
   @Test
-  public void getAlmSetting_whenAlmSettingExists_shouldReturnActualAlmSetting(){
+  public void getAlmConfig_whenConfigExists_shouldReturnConfig(){
     AlmSettingDto almSettingDto = db.almSettings().insertAzureAlmSetting();
-    when( request.mandatoryParam(ImportHelper.PARAM_ALM_SETTING)).thenReturn(almSettingDto.getKey());
+    Request request = new SimpleGetRequest()
+      .setParam(PARAM_ALM_SETTING, almSettingDto.getKey());
 
-    AlmSettingDto result = underTest.getAlmSetting(request);
+    AlmSettingDto result = underTest.getAlmSettingDtoForAlm(request, GITHUB_ALM);
 
     assertThat(result.getUuid()).isEqualTo(almSettingDto.getUuid());
   }
+
+  @Test
+  public void getUserUuid_whenUserUuidNull_shouldThrow() {
+    assertThatThrownBy(underTest::getUserUuid)
+      .isInstanceOf(NullPointerException.class)
+      .hasMessage("User UUID cannot be null.");
+  }
+
+  @Test
+  public void toCreateResponse_shouldReturnProjectResponse() {
+    CreateWsResponse response = ImportHelper.toCreateResponse(projectDto);
+    CreateWsResponse.Project project = response.getProject();
+
+    assertThat(project).extracting(CreateWsResponse.Project::getKey, CreateWsResponse.Project::getName,
+        CreateWsResponse.Project::getQualifier)
+      .containsExactly(projectDto.getKey(), projectDto.getName(), projectDto.getQualifier());
+  }
 }

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/SetPatActionIT.java

 import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.exceptions.UnauthorizedException;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.sonar.db.permission.GlobalPermission.PROVISION_PROJECTS;
   @Rule
   public DbTester db = DbTester.create();
 
-  private final WsActionTester ws = new WsActionTester(new SetPatAction(db.getDbClient(), userSession));
+  public ImportHelper importHelper = new ImportHelper(db.getDbClient(), userSession);
+
+  private final WsActionTester ws = new WsActionTester(new SetPatAction(db.getDbClient(), userSession, importHelper));
 
   @Test
   public void set_new_azuredevops_pat() {
       .hasMessage("Username cannot be null for Bitbucket Cloud");
   }
 
-  @Test
-  public void fail_when_alm_setting_unknow() {
-    UserDto user = db.users().insertUser();
-    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
-
-    assertThatThrownBy(() -> {
-      ws.newRequest()
-        .setParam("almSetting", "notExistingKey")
-        .setParam("pat", "12345678987654321")
-        .execute();
-    })
-      .isInstanceOf(NotFoundException.class)
-      .hasMessage("DevOps Platform Setting 'notExistingKey' not found");
-  }
-
   @Test
   public void set_new_github_pat() {
     UserDto user = db.users().insertUser();
       .hasMessage("Insufficient privileges");
   }
 
+  @Test
+  public void setPat_whenAlmSettingKeyDoesNotExist_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("almSetting", "unknown")
+      .setParam("pat", "12345678987654321");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
+  }
+
+  @Test
+  public void setPat_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("pat", "12345678987654321");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void setPat_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertAzureAlmSetting();
+    db.almSettings().insertGitHubAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("pat", "12345678987654321");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void setPat_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertAzureAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("pat", "12345678987654321");
+
+    assertThatNoException().isThrownBy(request::execute);
+  }
+
   @Test
   public void definition() {
     WebService.Action def = ws.getDef();
     assertThat(def.isPost()).isTrue();
     assertThat(def.params())
       .extracting(WebService.Param::key, WebService.Param::isRequired)
-      .containsExactlyInAnyOrder(tuple("almSetting", true), tuple("pat", true), tuple("username", false));
+      .containsExactlyInAnyOrder(
+        tuple("almSetting", false),
+        tuple("pat", true),
+        tuple("username", false));
   }
 
 }

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/azure/ImportAzureProjectActionIT.java

 import org.sonar.core.platform.PlatformEditionProvider;
 import org.sonar.core.util.SequenceUuidFactory;
 import org.sonar.db.DbTester;
-import org.sonar.db.alm.pat.AlmPatDto;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
 
 import static java.util.Objects.requireNonNull;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.sonar.db.alm.integration.pat.AlmPatsTesting.newAlmPatDto;
 import static org.sonar.db.component.BranchDto.DEFAULT_MAIN_BRANCH_NAME;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.NUMBER_OF_DAYS;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.REFERENCE_BRANCH;
       .hasMessage("personal access token for '" + almSetting.getKey() + "' is missing");
   }
 
-  @Test
-  public void fail_check_alm_setting_not_found() {
-    UserDto user = db.users().insertUser();
-    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
-    AlmPatDto almPatDto = newAlmPatDto();
-    db.getDbClient().almPatDao().insert(db.getSession(), almPatDto, user.getLogin(), null);
-
-    TestRequest request = ws.newRequest()
-      .setParam("almSetting", "testKey");
-
-    assertThatThrownBy(request::execute)
-      .isInstanceOf(NotFoundException.class)
-      .hasMessage("DevOps Platform Setting 'testKey' not found");
-  }
-
   @Test
   public void fail_project_already_exists() {
     AlmSettingDto almSetting = configureUserAndAlmSettings();
         GENERATED_PROJECT_KEY);
   }
 
+  @Test
+  public void importProject_whenAlmSettingKeyDoesNotExist_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("almSetting", "unknown")
+      .setParam("projectName", "project-name")
+      .setParam("repositoryName", "repo-name");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectName", "project-name")
+      .setParam("repositoryName", "repo-name");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no AZURE_DEVOPS configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertAzureAlmSetting();
+    db.almSettings().insertAzureAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectName", "project-name")
+      .setParam("repositoryName", "repo-name");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    AlmSettingDto almSetting = configureUserAndAlmSettings();
+    mockAzureInteractions(almSetting);
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectName", "project-name")
+      .setParam("repositoryName", "repo-name");
+
+    assertThatNoException().isThrownBy(request::execute);
+  }
+
+
   @Test
   public void define() {
     WebService.Action def = ws.getDef();
     assertThat(def.params())
       .extracting(WebService.Param::key, WebService.Param::isRequired)
       .containsExactlyInAnyOrder(
-        tuple("almSetting", true),
+        tuple("almSetting", false),
         tuple("projectName", true),
         tuple("repositoryName", true),
         tuple(PARAM_NEW_CODE_DEFINITION_TYPE, false),

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/bitbucketcloud/ImportBitbucketCloudRepoActionIT.java

 import org.sonar.core.platform.PlatformEditionProvider;
 import org.sonar.core.util.SequenceUuidFactory;
 import org.sonar.db.DbTester;
-import org.sonar.db.alm.pat.AlmPatDto;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
 
 import static java.util.Objects.requireNonNull;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.sonar.db.alm.integration.pat.AlmPatsTesting.newAlmPatDto;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.NUMBER_OF_DAYS;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.REFERENCE_BRANCH;
 import static org.sonar.db.permission.GlobalPermission.PROVISION_PROJECTS;
   }
 
   @Test
-  public void fail_check_alm_setting_not_found() {
+  public void fail_when_no_creation_project_permission() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user);
+
+    TestRequest request = ws.newRequest()
+      .setParam("almSetting", "anyvalue");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(ForbiddenException.class)
+      .hasMessageContaining("Insufficient privileges");
+  }
+
+  @Test
+  public void importProject_whenAlmSettingKeyDoesNotExist_shouldThrow() {
     UserDto user = db.users().insertUser();
     userSession.logIn(user).addPermission(PROVISION_PROJECTS);
-    AlmPatDto almPatDto = newAlmPatDto();
-    db.getDbClient().almPatDao().insert(db.getSession(), almPatDto, user.getLogin(), null);
 
     TestRequest request = ws.newRequest()
-      .setParam("almSetting", "testKey")
-      .setParam("repositorySlug", "repo");
+      .setParam("almSetting", "unknown")
+      .setParam("repositorySlug", "repo-slug");
 
     assertThatThrownBy(request::execute)
       .isInstanceOf(NotFoundException.class)
-      .hasMessageContaining("DevOps Platform Setting 'testKey' not found");
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
   }
 
   @Test
-  public void fail_when_no_creation_project_permission() {
+  public void importProject_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
     UserDto user = db.users().insertUser();
-    userSession.logIn(user);
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
 
     TestRequest request = ws.newRequest()
-      .setParam("almSetting", "anyvalue");
+      .setParam("repositorySlug", "repo-slug");
 
     assertThatThrownBy(request::execute)
-      .isInstanceOf(ForbiddenException.class)
-      .hasMessageContaining("Insufficient privileges");
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no BITBUCKET_CLOUD configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertBitbucketCloudAlmSetting();
+    db.almSettings().insertBitbucketCloudAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    configureUserAndPatAndAlmSettings();
+    mockBitbucketCloudRepo();
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectKey", "projectKey")
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatNoException().isThrownBy(request::execute);
   }
 
   @Test
     assertThat(def.params())
       .extracting(WebService.Param::key, WebService.Param::isRequired)
       .containsExactlyInAnyOrder(
-        tuple("almSetting", true),
+        tuple("almSetting", false),
         tuple("repositorySlug", true),
         tuple(PARAM_NEW_CODE_DEFINITION_TYPE, false),
         tuple(PARAM_NEW_CODE_DEFINITION_VALUE, false));

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/bitbucketserver/ImportBitbucketServerProjectActionIT.java

 import org.sonar.core.platform.PlatformEditionProvider;
 import org.sonar.core.util.SequenceUuidFactory;
 import org.sonar.db.DbTester;
-import org.sonar.db.alm.pat.AlmPatDto;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.component.BranchDto;
 import org.sonar.db.newcodeperiod.NewCodePeriodDto;
 import org.sonar.server.project.ProjectDefaultVisibility;
 import org.sonar.server.project.Visibility;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 import org.sonarqube.ws.Projects;
 
 import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
 import static org.apache.commons.lang.math.JVMRandom.nextLong;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
-import static org.sonar.db.alm.integration.pat.AlmPatsTesting.newAlmPatDto;
 import static org.sonar.db.component.BranchDto.DEFAULT_MAIN_BRANCH_NAME;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.NUMBER_OF_DAYS;
 import static org.sonar.db.newcodeperiod.NewCodePeriodType.REFERENCE_BRANCH;
       .hasMessage("personal access token for '" + almSetting.getKey() + "' is missing");
   }
 
-  @Test
-  public void fail_check_alm_setting_not_found() {
-    UserDto user = db.users().insertUser();
-    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
-    AlmPatDto almPatDto = newAlmPatDto();
-    db.getDbClient().almPatDao().insert(db.getSession(), almPatDto, user.getLogin(), null);
-
-    assertThatThrownBy(() -> {
-      ws.newRequest()
-        .setParam("almSetting", "testKey")
-        .execute();
-    })
-      .isInstanceOf(NotFoundException.class)
-      .hasMessage("DevOps Platform Setting 'testKey' not found");
-  }
-
   @Test
   public void fail_when_no_creation_project_permission() {
     UserDto user = db.users().insertUser();
     assertThat(mainBranchName).isEqualTo("default");
   }
 
+  @Test
+  public void importProject_whenAlmSettingKeyDoesNotExist_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("almSetting", "unknown")
+      .setParam("projectKey", "projectKey")
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectKey", "projectKey")
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no BITBUCKET configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertBitbucketAlmSetting();
+    db.almSettings().insertBitbucketAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectKey", "projectKey")
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    configureUserAndPatAndAlmSettings();
+    Project project = getGsonBBSProject();
+    mockBitbucketServerRepo(project);
+
+    TestRequest request = ws.newRequest()
+      .setParam("projectKey", "projectKey")
+      .setParam("repositorySlug", "repo-slug");
+
+    assertThatNoException().isThrownBy(request::execute);
+  }
+
   @Test
   public void definition() {
     WebService.Action def = ws.getDef();
     assertThat(def.params())
       .extracting(WebService.Param::key, WebService.Param::isRequired)
       .containsExactlyInAnyOrder(
-        tuple("almSetting", true),
+        tuple("almSetting", false),
         tuple("repositorySlug", true),
         tuple("projectKey", true),
         tuple(PARAM_NEW_CODE_DEFINITION_TYPE, false),
   private AlmSettingDto configureUserAndPatAndAlmSettings() {
     UserDto user = db.users().insertUser();
     userSession.logIn(user).addPermission(PROVISION_PROJECTS);
-    AlmSettingDto almSetting = db.almSettings().insertGitHubAlmSetting();
+    AlmSettingDto almSetting = db.almSettings().insertBitbucketAlmSetting();
     db.almPats().insert(dto -> {
       dto.setAlmSettingUuid(almSetting.getUuid());
       dto.setUserUuid(user.getUuid());

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/github/ImportGithubProjectActionIT.java

 
 import static java.util.Objects.requireNonNull;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
     assertThat(projectDto.orElseThrow().getCreationMethod()).isEqualTo(CreationMethod.ALM_IMPORT_BROWSER);
   }
 
+  @Test
+  public void importProject_whenAlmSettingKeyDoesNotExist_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(GlobalPermission.PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam(PARAM_ALM_SETTING, "unknown")
+      .setParam(PARAM_ORGANIZATION, "test")
+      .setParam(PARAM_REPOSITORY_KEY, "test/repo");
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(GlobalPermission.PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam(PARAM_ORGANIZATION, "test")
+      .setParam(PARAM_REPOSITORY_KEY, "test/repo");
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no GITHUB configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(GlobalPermission.PROVISION_PROJECTS);
+    db.almSettings().insertGitHubAlmSetting();
+    db.almSettings().insertGitHubAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam(PARAM_ORGANIZATION, "test")
+      .setParam(PARAM_REPOSITORY_KEY, "test/repo");
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    AlmSettingDto githubAlmSetting = setupUserWithPatAndAlmSettings();
+
+    mockGithubInteractions();
+    when(gitHubSettings.isProvisioningEnabled()).thenReturn(true);
+
+    TestRequest request = ws.newRequest()
+      .setParam(PARAM_ALM_SETTING, githubAlmSetting.getKey())
+      .setParam(PARAM_ORGANIZATION, "octocat")
+      .setParam(PARAM_REPOSITORY_KEY, "octocat/" + PROJECT_KEY_NAME);
+
+    assertThatNoException().isThrownBy(request::execute);
+  }
+
   private Projects.CreateWsResponse callWebService(AlmSettingDto githubAlmSetting) {
     return ws.newRequest()
       .setParam(PARAM_ALM_SETTING, githubAlmSetting.getKey())
       .isInstanceOf(UnauthorizedException.class);
   }
 
-  @Test
-  public void fail_when_almSetting_does_not_exist() {
-    UserDto user = db.users().insertUser();
-    userSession.logIn(user).addPermission(GlobalPermission.PROVISION_PROJECTS);
-
-    TestRequest request = ws.newRequest()
-      .setParam(PARAM_ALM_SETTING, "unknown")
-      .setParam(PARAM_ORGANIZATION, "test")
-      .setParam(PARAM_REPOSITORY_KEY, "test/repo");
-    assertThatThrownBy(request::execute)
-      .isInstanceOf(NotFoundException.class)
-      .hasMessage("DevOps Platform Setting 'unknown' not found");
-  }
-
   @Test
   public void fail_when_personal_access_token_doesnt_exist() {
     AlmSettingDto githubAlmSetting = setupUserAndAlmSettings();
     assertThat(def.params())
       .extracting(WebService.Param::key, WebService.Param::isRequired)
       .containsExactlyInAnyOrder(
-        tuple(PARAM_ALM_SETTING, true),
+        tuple(PARAM_ALM_SETTING, false),
         tuple(PARAM_ORGANIZATION, true),
         tuple(PARAM_REPOSITORY_KEY, true),
         tuple(PARAM_NEW_CODE_DEFINITION_TYPE, false),

server/sonar-webserver-webapi/src/it/java/org/sonar/server/almintegration/ws/gitlab/ImportGitLabProjectActionIT.java

 import org.sonar.server.almintegration.ws.ProjectKeyGenerator;
 import org.sonar.server.component.ComponentUpdater;
 import org.sonar.server.es.TestIndexers;
+import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.favorite.FavoriteUpdater;
 import org.sonar.server.newcodeperiod.NewCodeDefinitionResolver;
 import org.sonar.server.permission.PermissionService;
 import org.sonar.server.project.ProjectDefaultVisibility;
 import org.sonar.server.project.Visibility;
 import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.ws.TestRequest;
 import org.sonar.server.ws.WsActionTester;
 import org.sonarqube.ws.Projects;
 
 import static java.util.Collections.singletonList;
 import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatNoException;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
     assertThat(projectDto.orElseThrow().getCreationMethod()).isEqualTo(CreationMethod.ALM_IMPORT_BROWSER);
   }
 
+  @Test
+  public void importProject_whenAlmSettingKeyDoesNotExist_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("almSetting", "unknown")
+      .setParam("gitlabProjectId", "12345");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("DevOps Platform configuration 'unknown' not found.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndNoConfig_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    TestRequest request = ws.newRequest()
+      .setParam("gitlabProjectId", "12345");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(NotFoundException.class)
+      .hasMessage("There is no GITLAB configuration for DevOps Platform. Please add one.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndMultipleConfigs_shouldThrow() {
+    UserDto user = db.users().insertUser();
+    userSession.logIn(user).addPermission(PROVISION_PROJECTS);
+
+    db.almSettings().insertGitlabAlmSetting();
+    db.almSettings().insertGitlabAlmSetting();
+
+    TestRequest request = ws.newRequest()
+      .setParam("gitlabProjectId", "12345");
+
+    assertThatThrownBy(request::execute)
+      .isInstanceOf(IllegalArgumentException.class)
+      .hasMessage("Parameter almSetting is required as there are multiple DevOps Platform configurations.");
+  }
+
+  @Test
+  public void importProject_whenNoAlmSettingKeyAndOnlyOneConfig_shouldImport() {
+    configureUserAndPatAndAlmSettings();
+    mockGitlabProject(emptyList());
+
+    TestRequest request = ws.newRequest()
+      .setParam("gitlabProjectId", "12345");
+
+    assertThatNoException().isThrownBy(request::execute);
+  }
+
+
   private AlmSettingDto configureUserAndPatAndAlmSettings() {
     UserDto user = db.users().insertUser();
     userSession.logIn(user).addPermission(PROVISION_PROJECTS);

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/ImportHelper.java

  */
 package org.sonar.server.almintegration.ws;
 
+import java.util.List;
+import javax.annotation.Nullable;
 import org.sonar.api.server.ServerSide;
 import org.sonar.api.server.ws.Request;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.project.ProjectDto;
 import org.sonar.server.exceptions.NotFoundException;
     userSession.checkLoggedIn().checkPermission(PROVISION_PROJECTS);
   }
 
-  public AlmSettingDto getAlmSetting(Request request) {
-    String almSettingKey = request.mandatoryParam(PARAM_ALM_SETTING);
+  public AlmSettingDto getAlmSettingDto(Request request) {
+    return getAlmSettingDto(request, null);
+  }
+
+  public AlmSettingDto getAlmSettingDtoForAlm(Request request, ALM alm) {
+    return getAlmSettingDto(request, alm);
+  }
+
+  private AlmSettingDto getAlmSettingDto(Request request, @Nullable ALM alm) {
     try (DbSession dbSession = dbClient.openSession(false)) {
-      return dbClient.almSettingDao().selectByKey(dbSession, almSettingKey)
-        .orElseThrow(() -> new NotFoundException(String.format("DevOps Platform Setting '%s' not found", almSettingKey)));
+      String almSettingKey = request.param(PARAM_ALM_SETTING);
+      if (almSettingKey != null) {
+        return getAlmSettingDtoFromKey(dbSession, almSettingKey);
+      }
+      return getUniqueAlmSettingDtoForAlm(dbSession, alm);
+    }
+  }
+
+  private AlmSettingDto getAlmSettingDtoFromKey(DbSession dbSession, String almSettingKey) {
+    return dbClient.almSettingDao().selectByKey(dbSession, almSettingKey)
+      .orElseThrow(() -> new NotFoundException(String.format("DevOps Platform configuration '%s' not found.", almSettingKey)));
+  }
+
+  private AlmSettingDto getUniqueAlmSettingDtoForAlm(DbSession dbSession, @Nullable ALM alm) {
+    List<AlmSettingDto> almSettingDtos = getAlmSettingDtos(dbSession, alm);
+
+    if (almSettingDtos.isEmpty()) {
+      String almString = alm == null ? "" : (alm.name() + " ");
+      throw new NotFoundException("There is no " + almString + "configuration for DevOps Platform. Please add one.");
+    }
+    if (almSettingDtos.size() == 1) {
+      return almSettingDtos.get(0);
+    }
+    throw new IllegalArgumentException(String.format("Parameter %s is required as there are multiple DevOps Platform configurations.", PARAM_ALM_SETTING));
+  }
+
+  private List<AlmSettingDto> getAlmSettingDtos(DbSession dbSession, @Nullable ALM alm) {
+    if (alm == null) {
+      return dbClient.almSettingDao().selectAll(dbSession);
     }
+    return dbClient.almSettingDao().selectByAlm(dbSession, alm);
   }
 
   public String getUserUuid() {
-    return requireNonNull(userSession.getUuid(), "User UUID cannot be null");
+    return requireNonNull(userSession.getUuid(), "User UUID cannot be null.");
   }
 
   public static CreateWsResponse toCreateResponse(ProjectDto projectDto) {

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/SetPatAction.java

 package org.sonar.server.almintegration.ws;
 
 import com.google.common.base.Strings;
+import java.util.List;
 import java.util.Optional;
+import javax.annotation.Nullable;
 import org.sonar.api.server.ws.Change;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.server.exceptions.NotFoundException;
 import org.sonar.server.user.UserSession;
 
-import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
 import static org.sonar.db.alm.setting.ALM.BITBUCKET_CLOUD;
 import static org.sonar.db.permission.GlobalPermission.PROVISION_PROJECTS;
 
   private final DbClient dbClient;
   private final UserSession userSession;
+  private final ImportHelper importHelper;
 
-  public SetPatAction(DbClient dbClient, UserSession userSession) {
+  public SetPatAction(DbClient dbClient, UserSession userSession, ImportHelper importHelper) {
     this.dbClient = dbClient;
     this.userSession = userSession;
+    this.importHelper = importHelper;
   }
 
   @Override
       .setHandler(this)
       .setChangelog(
         new Change("9.0", "Bitbucket Cloud support and optional Username parameter were added"),
-        new Change("10.3", "Allow setting Personal Access Tokens for all DevOps platforms"));
+        new Change("10.3", "Allow setting Personal Access Tokens for all DevOps platforms"),
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one DevOps Platform configuration", PARAM_ALM_SETTING)));
 
     action.createParam(PARAM_ALM_SETTING)
-      .setRequired(true)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one single DevOps Platform integration.");
+
     action.createParam(PARAM_PAT)
       .setRequired(true)
       .setMaximumLength(2000)
       .setDescription("Personal Access Token");
+
     action.createParam(PARAM_USERNAME)
       .setRequired(false)
       .setMaximumLength(2000)
       userSession.checkLoggedIn().checkPermission(PROVISION_PROJECTS);
 
       String pat = request.mandatoryParam(PARAM_PAT);
-      String almSettingKey = request.mandatoryParam(PARAM_ALM_SETTING);
       String username = request.param(PARAM_USERNAME);
 
       String userUuid = requireNonNull(userSession.getUuid(), "User UUID cannot be null");
-      AlmSettingDto almSetting = dbClient.almSettingDao().selectByKey(dbSession, almSettingKey)
-        .orElseThrow(() -> new NotFoundException(format("DevOps Platform Setting '%s' not found", almSettingKey)));
+      AlmSettingDto almSettingDto = importHelper.getAlmSettingDto(request);
 
-      if (almSetting.getAlm().equals(BITBUCKET_CLOUD)) {
+      if (almSettingDto.getAlm().equals(BITBUCKET_CLOUD)) {
         Preconditions.checkArgument(!Strings.isNullOrEmpty(username), "Username cannot be null for Bitbucket Cloud");
       }
 
-      String resultingPat = CredentialsEncoderHelper.encodeCredentials(almSetting.getAlm(), pat, username);
+      String resultingPat = CredentialsEncoderHelper.encodeCredentials(almSettingDto.getAlm(), pat, username);
 
-      Optional<AlmPatDto> almPatDto = dbClient.almPatDao().selectByUserAndAlmSetting(dbSession, userUuid, almSetting);
+      Optional<AlmPatDto> almPatDto = dbClient.almPatDao().selectByUserAndAlmSetting(dbSession, userUuid, almSettingDto);
       if (almPatDto.isPresent()) {
         AlmPatDto almPat = almPatDto.get();
         almPat.setPersonalAccessToken(resultingPat);
-        dbClient.almPatDao().update(dbSession, almPat, userSession.getLogin(), almSetting.getKey());
+        dbClient.almPatDao().update(dbSession, almPat, userSession.getLogin(), almSettingDto.getKey());
       } else {
         AlmPatDto almPat = new AlmPatDto()
           .setPersonalAccessToken(resultingPat)
-          .setAlmSettingUuid(almSetting.getUuid())
+          .setAlmSettingUuid(almSettingDto.getUuid())
           .setUserUuid(userUuid);
-        dbClient.almPatDao().insert(dbSession, almPat, userSession.getLogin(), almSetting.getKey());
+        dbClient.almPatDao().insert(dbSession, almPat, userSession.getLogin(), almSettingDto.getKey());
       }
       dbSession.commit();
     }
   }
+
+  public AlmSettingDto getAlmConfig(@Nullable String almSettingKey) {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      if (almSettingKey != null) {
+        return getAlmSettingDtoFromKey(dbSession, almSettingKey);
+      }
+      return getAlmSettingDtoFromAlm(dbSession);
+    }
+  }
+
+  private AlmSettingDto getAlmSettingDtoFromKey(DbSession dbSession, String almSettingKey) {
+    return dbClient.almSettingDao().selectByKey(dbSession, almSettingKey)
+      .orElseThrow(() -> new NotFoundException(String.format("DevOps Platform configuration '%s' not found.", almSettingKey)));
+  }
+
+  private AlmSettingDto getAlmSettingDtoFromAlm(DbSession dbSession) {
+    List<AlmSettingDto> almSettingDtos = dbClient.almSettingDao().selectAll(dbSession);
+    if (almSettingDtos.isEmpty()) {
+      throw new NotFoundException("There is no configuration for DevOps Platforms. Please add one.");
+    }
+    if (almSettingDtos.size() == 1) {
+      return almSettingDtos.get(0);
+    }
+    throw new IllegalArgumentException(String.format("Parameter %s is required as there are multiple DevOps Platform configurations.", PARAM_ALM_SETTING));
+  }
+
 }

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/azure/ImportAzureProjectAction.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.alm.pat.AlmPatDto;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
       .setSince("8.6")
       .setHandler(this)
       .setChangelog(
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one configuration for Azure", PARAM_ALM_SETTING)),
         new Change("10.3", "Endpoint visibility change from internal to public"));
 
     action.createParam(PARAM_ALM_SETTING)
-      .setRequired(true)
       .setMaximumLength(200)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one Azure integration.");
 
     action.createParam(PARAM_PROJECT_NAME)
       .setRequired(true)
 
   private CreateWsResponse doHandle(Request request) {
     importHelper.checkProvisionProjectPermission();
-    AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
+    AlmSettingDto almSettingDto = importHelper.getAlmSettingDtoForAlm(request, ALM.AZURE_DEVOPS);
 
     String newCodeDefinitionType = request.param(PARAM_NEW_CODE_DEFINITION_TYPE);
     String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/bitbucketcloud/ImportBitbucketCloudRepoAction.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.alm.pat.AlmPatDto;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
       .setSince("9.0")
       .setHandler(this)
       .setChangelog(
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one configuration for BitBucket Cloud", PARAM_ALM_SETTING)),
         new Change("10.3", "Endpoint visibility change from internal to public"));
 
     action.createParam(PARAM_REPO_SLUG)
       .setDescription("Bitbucket Cloud repository slug");
 
     action.createParam(PARAM_ALM_SETTING)
-      .setRequired(true)
       .setMaximumLength(200)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one BitBucket Cloud integration.");
 
     action.createParam(PARAM_NEW_CODE_DEFINITION_TYPE)
       .setDescription(NEW_CODE_PERIOD_TYPE_DESCRIPTION_PROJECT_CREATION)
     String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);
 
     String repoSlug = request.mandatoryParam(PARAM_REPO_SLUG);
-    AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
+    AlmSettingDto almSettingDto = importHelper.getAlmSettingDtoForAlm(request, ALM.BITBUCKET_CLOUD);
     String workspace = ofNullable(almSettingDto.getAppId())
       .orElseThrow(() -> new IllegalArgumentException(String.format("workspace for alm setting %s is missing", almSettingDto.getKey())));
 

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/bitbucketserver/ImportBitbucketServerProjectAction.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.alm.pat.AlmPatDto;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
       .setSince("8.2")
       .setHandler(this)
       .setChangelog(
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one configuration for BitBucket Server", PARAM_ALM_SETTING)),
         new Change("10.3", "Endpoint visibility change from internal to public"));
 
     action.createParam(PARAM_ALM_SETTING)
-      .setRequired(true)
       .setMaximumLength(200)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one BitBucket Server integration.");
 
     action.createParam(PARAM_PROJECT_KEY)
       .setRequired(true)
 
   private Projects.CreateWsResponse doHandle(Request request) {
     importHelper.checkProvisionProjectPermission();
-    AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
+    AlmSettingDto almSettingDto = importHelper.getAlmSettingDtoForAlm(request, ALM.BITBUCKET);
 
     String newCodeDefinitionType = request.param(PARAM_NEW_CODE_DEFINITION_TYPE);
     String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/github/ImportGithubProjectAction.java

 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.alm.pat.AlmPatDto;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
       .setSince("8.4")
       .setHandler(this)
       .setChangelog(
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one configuration for GitHub", PARAM_ALM_SETTING)),
         new Change("10.3", "Endpoint visibility change from internal to public"));
 
     action.createParam(PARAM_ALM_SETTING)
-      .setRequired(true)
       .setMaximumLength(200)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one GitHub integration.");
 
     action.createParam(PARAM_ORGANIZATION)
       .setRequired(true)
 
   private Projects.CreateWsResponse doHandle(Request request) {
     importHelper.checkProvisionProjectPermission();
-    AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
+    AlmSettingDto almSettingDto = importHelper.getAlmSettingDtoForAlm(request, ALM.GITHUB);
 
     String newCodeDefinitionType = request.param(PARAM_NEW_CODE_DEFINITION_TYPE);
     String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);

server/sonar-webserver-webapi/src/main/java/org/sonar/server/almintegration/ws/gitlab/ImportGitLabProjectAction.java

 import org.sonar.alm.client.gitlab.GitLabBranch;
 import org.sonar.alm.client.gitlab.GitlabHttpClient;
 import org.sonar.alm.client.gitlab.Project;
+import org.sonar.api.server.ws.Change;
 import org.sonar.api.server.ws.Request;
 import org.sonar.api.server.ws.Response;
 import org.sonar.api.server.ws.WebService;
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
 import org.sonar.db.alm.pat.AlmPatDto;
+import org.sonar.db.alm.setting.ALM;
 import org.sonar.db.alm.setting.AlmSettingDto;
 import org.sonar.db.alm.setting.ProjectAlmSettingDto;
 import org.sonar.db.component.BranchDto;
 import static org.sonar.api.resources.Qualifiers.PROJECT;
 import static org.sonar.db.project.CreationMethod.Category.ALM_IMPORT;
 import static org.sonar.db.project.CreationMethod.getCreationMethod;
+import static org.sonar.server.almintegration.ws.ImportHelper.PARAM_ALM_SETTING;
 import static org.sonar.server.component.NewComponent.newComponentBuilder;
 import static org.sonar.server.newcodeperiod.NewCodeDefinitionResolver.NEW_CODE_PERIOD_TYPE_DESCRIPTION_PROJECT_CREATION;
 import static org.sonar.server.newcodeperiod.NewCodeDefinitionResolver.NEW_CODE_PERIOD_VALUE_DESCRIPTION_PROJECT_CREATION;
                       "Requires the 'Create Projects' permission")
       .setPost(true)
       .setSince("8.5")
-      .setHandler(this);
+      .setHandler(this)
+      .setChangelog(
+        new Change("10.3", String.format("Parameter %s becomes optional if you have only one configuration for GitLab", PARAM_ALM_SETTING)));
 
     action.createParam(ImportHelper.PARAM_ALM_SETTING)
-      .setRequired(true)
-      .setDescription("DevOps Platform setting key");
+      .setDescription("DevOps Platform configuration key. This parameter is optional if you have only one GitLab integration.");
+
     action.createParam(PARAM_GITLAB_PROJECT_ID)
       .setRequired(true)
       .setDescription("GitLab project ID");
     String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);
 
     try (DbSession dbSession = dbClient.openSession(false)) {
-      AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
+      AlmSettingDto almSettingDto = importHelper.getAlmSettingDtoForAlm(request, ALM.GITLAB);
       String pat = getPat(dbSession, almSettingDto);
 
       long gitlabProjectId = request.mandatoryParamAsLong(PARAM_GITLAB_PROJECT_ID);