import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import org.sonar.alm.client.github.GithubApplicationClient;
import org.sonar.alm.client.github.GithubApplicationClientImpl;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
+import org.sonar.auth.github.GitHubSettings;
import org.sonar.core.i18n.I18n;
import org.sonar.core.platform.EditionProvider;
import org.sonar.core.platform.PlatformEditionProvider;
import org.sonar.core.util.SequenceUuidFactory;
+import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.alm.setting.AlmSettingDto;
import org.sonar.db.component.BranchDto;
+import org.sonar.db.entity.EntityDto;
import org.sonar.db.newcodeperiod.NewCodePeriodDto;
import org.sonar.db.permission.GlobalPermission;
import org.sonar.db.project.ProjectDto;
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.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.sonar.db.component.BranchDto.DEFAULT_MAIN_BRANCH_NAME;
import static org.sonar.db.newcodeperiod.NewCodePeriodType.NUMBER_OF_DAYS;
@Rule
public DbTester db = DbTester.create(system2);
-
-
+ private final PermissionTemplateService permissionTemplateService = mock(PermissionTemplateService.class);
private final ComponentUpdater componentUpdater = new ComponentUpdater(db.getDbClient(), mock(I18n.class), System2.INSTANCE,
- mock(PermissionTemplateService.class), new FavoriteUpdater(db.getDbClient()), new TestIndexers(), new SequenceUuidFactory(),
+ permissionTemplateService, new FavoriteUpdater(db.getDbClient()), new TestIndexers(), new SequenceUuidFactory(),
defaultBranchNameResolver, true);
private final ImportHelper importHelper = new ImportHelper(db.getDbClient(), userSession);
private final ProjectKeyGenerator projectKeyGenerator = mock(ProjectKeyGenerator.class);
private final ProjectDefaultVisibility projectDefaultVisibility = mock(ProjectDefaultVisibility.class);
private PlatformEditionProvider editionProvider = mock(PlatformEditionProvider.class);
+
+ private final GitHubSettings gitHubSettings = mock(GitHubSettings.class);
private NewCodeDefinitionResolver newCodeDefinitionResolver = new NewCodeDefinitionResolver(db.getDbClient(), editionProvider);
+
private final WsActionTester ws = new WsActionTester(new ImportGithubProjectAction(db.getDbClient(), userSession,
projectDefaultVisibility, appClient, componentUpdater, importHelper, projectKeyGenerator, newCodeDefinitionResolver,
- defaultBranchNameResolver));
+ defaultBranchNameResolver, gitHubSettings));
@Before
public void before() {
Optional<ProjectDto> projectDto = db.getDbClient().projectDao().selectProjectByKey(db.getSession(), result.getKey());
assertThat(projectDto).isPresent();
assertThat(db.getDbClient().projectAlmSettingDao().selectByProject(db.getSession(), projectDto.get())).isPresent();
- Optional<BranchDto> mainBranch =
- db.getDbClient().branchDao().selectByProject(db.getSession(), projectDto.get()).stream().filter(BranchDto::isMain).findAny();
+ Optional<BranchDto> mainBranch = db.getDbClient().branchDao().selectByProject(db.getSession(), projectDto.get()).stream().filter(BranchDto::isMain).findAny();
assertThat(mainBranch).isPresent();
assertThat(mainBranch.get().getKey()).isEqualTo("default-branch");
assertThat(result.getName()).isEqualTo(repository.getName());
}
+ @Test
+ public void importProject_whenGithubProvisioningIsDisabled_shouldApplyPermissionTemplate() {
+ AlmSettingDto githubAlmSetting = setupAlm();
+ db.almPats().insert(p -> p.setAlmSettingUuid(githubAlmSetting.getUuid()).setUserUuid(userSession.getUuid()));
+
+ GithubApplicationClient.Repository repository = new GithubApplicationClient.Repository(1L, PROJECT_KEY_NAME, false,
+ "octocat/" + PROJECT_KEY_NAME,
+ "https://github.sonarsource.com/api/v3/repos/octocat/" + PROJECT_KEY_NAME, "default-branch");
+ when(appClient.getRepository(any(), any(), any(), any())).thenReturn(Optional.of(repository));
+ when(projectKeyGenerator.generateUniqueProjectKey(repository.getFullName())).thenReturn(PROJECT_KEY_NAME);
+ when(gitHubSettings.isProvisioningEnabled()).thenReturn(false);
+
+ ws.newRequest()
+ .setParam(PARAM_ALM_SETTING, githubAlmSetting.getKey())
+ .setParam(PARAM_ORGANIZATION, "octocat")
+ .setParam(PARAM_REPOSITORY_KEY, "octocat/" + PROJECT_KEY_NAME)
+ .executeProtobuf(Projects.CreateWsResponse.class);
+
+ ArgumentCaptor<EntityDto> projectDtoArgumentCaptor = ArgumentCaptor.forClass(EntityDto.class);
+ verify(permissionTemplateService).applyDefaultToNewComponent(any(DbSession.class), projectDtoArgumentCaptor.capture(), eq(userSession.getUuid()));
+ String projectKey = projectDtoArgumentCaptor.getValue().getKey();
+ assertThat(projectKey).isEqualTo(PROJECT_KEY_NAME);
+
+ }
+
+ @Test
+ public void importProject_whenGithubProvisioningIsEnabled_shouldNotApplyPermissionTemplate() {
+ AlmSettingDto githubAlmSetting = setupAlm();
+ db.almPats().insert(p -> p.setAlmSettingUuid(githubAlmSetting.getUuid()).setUserUuid(userSession.getUuid()));
+
+ GithubApplicationClient.Repository repository = new GithubApplicationClient.Repository(1L, PROJECT_KEY_NAME, false,
+ "octocat/" + PROJECT_KEY_NAME,
+ "https://github.sonarsource.com/api/v3/repos/octocat/" + PROJECT_KEY_NAME, "default-branch");
+ when(appClient.getRepository(any(), any(), any(), any())).thenReturn(Optional.of(repository));
+ when(projectKeyGenerator.generateUniqueProjectKey(repository.getFullName())).thenReturn(PROJECT_KEY_NAME);
+ when(gitHubSettings.isProvisioningEnabled()).thenReturn(true);
+
+ ws.newRequest()
+ .setParam(PARAM_ALM_SETTING, githubAlmSetting.getKey())
+ .setParam(PARAM_ORGANIZATION, "octocat")
+ .setParam(PARAM_REPOSITORY_KEY, "octocat/" + PROJECT_KEY_NAME)
+ .executeProtobuf(Projects.CreateWsResponse.class);
+
+ verify(permissionTemplateService, never()).applyDefaultToNewComponent(any(), any(), any());
+
+ }
+
@Test
public void fail_when_not_logged_in() {
TestRequest request = ws.newRequest()
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
+import org.sonar.auth.github.GitHubSettings;
import org.sonar.db.DbClient;
import org.sonar.db.DbSession;
import org.sonar.db.alm.pat.AlmPatDto;
import org.sonar.server.almintegration.ws.ProjectKeyGenerator;
import org.sonar.server.component.ComponentCreationData;
import org.sonar.server.component.ComponentUpdater;
+import org.sonar.server.component.NewComponent;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.newcodeperiod.NewCodeDefinitionResolver;
import org.sonar.server.project.DefaultBranchNameResolver;
private final DefaultBranchNameResolver defaultBranchNameResolver;
+ private final GitHubSettings gitHubSettings;
+
@Inject
public ImportGithubProjectAction(DbClient dbClient, UserSession userSession, ProjectDefaultVisibility projectDefaultVisibility,
GithubApplicationClientImpl githubApplicationClient, ComponentUpdater componentUpdater, ImportHelper importHelper,
ProjectKeyGenerator projectKeyGenerator, NewCodeDefinitionResolver newCodeDefinitionResolver,
- DefaultBranchNameResolver defaultBranchNameResolver) {
+ DefaultBranchNameResolver defaultBranchNameResolver, GitHubSettings gitHubSettings) {
this.dbClient = dbClient;
this.userSession = userSession;
this.projectDefaultVisibility = projectDefaultVisibility;
this.projectKeyGenerator = projectKeyGenerator;
this.newCodeDefinitionResolver = newCodeDefinitionResolver;
this.defaultBranchNameResolver = defaultBranchNameResolver;
+ this.gitHubSettings = gitHubSettings;
}
@Override
importHelper.checkProvisionProjectPermission();
AlmSettingDto almSettingDto = importHelper.getAlmSetting(request);
-
String newCodeDefinitionType = request.param(PARAM_NEW_CODE_DEFINITION_TYPE);
String newCodeDefinitionValue = request.param(PARAM_NEW_CODE_DEFINITION_VALUE);
try (DbSession dbSession = dbClient.openSession(false)) {
private ComponentCreationData createProject(DbSession dbSession, Repository repo, String mainBranchName) {
boolean visibility = projectDefaultVisibility.get(dbSession).isPrivate();
String uniqueProjectKey = projectKeyGenerator.generateUniqueProjectKey(repo.getFullName());
- return componentUpdater.createWithoutCommit(dbSession, newComponentBuilder()
- .setKey(uniqueProjectKey)
- .setName(repo.getName())
- .setPrivate(visibility)
- .setQualifier(PROJECT)
- .build(),
- userSession.getUuid(), userSession.getLogin(), mainBranchName);
+ NewComponent projectComponent = newComponentBuilder()
+ .setKey(uniqueProjectKey)
+ .setName(repo.getName())
+ .setPrivate(visibility)
+ .setQualifier(PROJECT)
+ .build();
+ return componentUpdater.createWithoutCommit(
+ dbSession,
+ projectComponent,
+ userSession.getUuid(),
+ userSession.getLogin(),
+ mainBranchName,
+ gitHubSettings.isProvisioningEnabled());
}
private void populatePRSetting(DbSession dbSession, Repository repo, ProjectDto projectDto, AlmSettingDto almSettingDto) {
*/
public ComponentCreationData createWithoutCommit(DbSession dbSession, NewComponent newComponent,
@Nullable String userUuid, @Nullable String userLogin) {
- return createWithoutCommit(dbSession, newComponent, userUuid, userLogin, null);
+ return createWithoutCommit(dbSession, newComponent, userUuid, userLogin, null, false);
+ }
+
+ public ComponentCreationData createWithoutCommit(DbSession dbSession, NewComponent newComponent,
+ @Nullable String userUuid, @Nullable String userLogin, @Nullable String mainBranchName) {
+ return createWithoutCommit(dbSession, newComponent, userUuid, userLogin, mainBranchName, false);
}
/**
* Don't forget to call commitAndIndex(...) when ready to commit.
*/
public ComponentCreationData createWithoutCommit(DbSession dbSession, NewComponent newComponent,
- @Nullable String userUuid, @Nullable String userLogin, @Nullable String mainBranchName) {
+ @Nullable String userUuid, @Nullable String userLogin, @Nullable String mainBranchName, boolean isManaged) {
checkKeyFormat(newComponent.qualifier(), newComponent.key());
checkKeyAlreadyExists(dbSession, newComponent);
dbClient.projectDao().insert(dbSession, projectDto);
addToFavourites(dbSession, projectDto, userUuid, userLogin);
mainBranch = createMainBranch(dbSession, componentDto.uuid(), projectDto.getUuid(), mainBranchName);
- permissionTemplateService.applyDefaultToNewComponent(dbSession, projectDto, userUuid);
+ if (!isManaged) {
+ permissionTemplateService.applyDefaultToNewComponent(dbSession, projectDto, userUuid);
+ }
} else if (isPortfolio(componentDto)) {
portfolioDto = toPortfolioDto(componentDto, now);
dbClient.portfolioDao().insert(dbSession, portfolioDto);