import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.db.DbSession;
public class ExternalGroupDaoIT {
+ private static final String GROUP_UUID = "uuid";
+ private static final String EXTERNAL_ID = "external_id";
+ private static final String EXTERNAL_IDENTITY_PROVIDER = "external_identity_provider";
+
@Rule
public final DbTester db = DbTester.create();
@Test
public void insert_savesExternalGroup() {
- GroupDto localGroup = insertGroup("12345");
+ GroupDto localGroup = insertGroup(GROUP_UUID);
insertGroup("67689");
- ExternalGroupDto externalGroupDto = externalGroup("12345", "providerId");
+ ExternalGroupDto externalGroupDto = externalGroup(GROUP_UUID, EXTERNAL_IDENTITY_PROVIDER);
underTest.insert(dbSession, externalGroupDto);
- List<ExternalGroupDto> savedGroups = underTest.selectByIdentityProvider(dbSession, "providerId");
+ List<ExternalGroupDto> savedGroups = underTest.selectByIdentityProvider(dbSession, EXTERNAL_IDENTITY_PROVIDER);
assertThat(savedGroups)
.hasSize(1)
.contains(createExternalGroupDto(localGroup.getName(), externalGroupDto));
}
+ @Test
+ public void selectByGroupUuid_shouldReturnExternalGroup() {
+ ExternalGroupDto expectedExternalGroupDto = new ExternalGroupDto(GROUP_UUID, EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER);
+ underTest.insert(dbSession, expectedExternalGroupDto);
+
+ Optional<ExternalGroupDto> actualExternalGroupDto = underTest.selectByGroupUuid(dbSession, GROUP_UUID);
+
+ assertThat(actualExternalGroupDto).isPresent();
+ compareExpectedAndActualExternalGroupDto(expectedExternalGroupDto, actualExternalGroupDto.get());
+ }
+
@Test
public void selectByIdentityProvider_returnOnlyGroupForTheIdentityProvider() {
List<ExternalGroupDto> expectedGroups = createAndInsertExternalGroupDtos("provider1", 3);
assertThat(savedGroup).containsExactlyInAnyOrderElementsOf(expectedGroups);
}
+ @Test
+ public void selectByExternalIdAndIdentityProvider_shouldReturnOnlyMatchingExternalGroup() {
+ ExternalGroupDto expectedExternalGroupDto = new ExternalGroupDto(GROUP_UUID, EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER);
+ underTest.insert(dbSession, expectedExternalGroupDto);
+ underTest.insert(dbSession, new ExternalGroupDto(GROUP_UUID + "1", EXTERNAL_ID, "another_external_identity_provider"));
+ underTest.insert(dbSession, new ExternalGroupDto(GROUP_UUID + "2", "another_external_id", EXTERNAL_IDENTITY_PROVIDER));
+ underTest.insert(dbSession, new ExternalGroupDto(GROUP_UUID + "3", "whatever", "whatever"));
+
+ Optional<ExternalGroupDto> actualExternalGroupDto = underTest.selectByExternalIdAndIdentityProvider(dbSession, EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER);
+
+ compareExpectedAndActualExternalGroupDto(expectedExternalGroupDto, actualExternalGroupDto.get());
+ }
+
+ private void compareExpectedAndActualExternalGroupDto(ExternalGroupDto expectedExternalGroupDto, ExternalGroupDto actualExternalGroupDto) {
+ assertThat(actualExternalGroupDto)
+ .usingRecursiveComparison()
+ .isEqualTo(expectedExternalGroupDto);
+ }
+
@Test
public void deleteByGroupUuid_deletesTheGroup() {
List<ExternalGroupDto> insertedGroups = createAndInsertExternalGroupDtos("provider1", 3);
package org.sonar.db.user;
import java.util.List;
+import java.util.Optional;
import org.sonar.db.Dao;
import org.sonar.db.DbSession;
mapper(dbSession).insert(externalGroupDto);
}
+ public Optional<ExternalGroupDto> selectByGroupUuid(DbSession dbSession, String groupUuid) {
+ return mapper(dbSession).selectByGroupUuid(groupUuid);
+ }
+
public List<ExternalGroupDto> selectByIdentityProvider(DbSession dbSession, String identityProvider) {
return mapper(dbSession).selectByIdentityProvider(identityProvider);
}
mapper(dbSession).deleteByGroupUuid(groupUuid);
}
+ public Optional<ExternalGroupDto> selectByExternalIdAndIdentityProvider(DbSession dbSession, String externalId, String identityProvider) {
+ return mapper(dbSession).selectByExternalIdAndIdentityProvider(externalId, identityProvider);
+ }
+
private static ExternalGroupMapper mapper(DbSession session) {
return session.getMapper(ExternalGroupMapper.class);
}
package org.sonar.db.user;
import java.util.List;
+import java.util.Optional;
import org.apache.ibatis.annotations.Param;
public interface ExternalGroupMapper {
void insert(ExternalGroupDto externalGroupDto);
- List<ExternalGroupDto> selectByIdentityProvider(String identityProvider);
+ Optional<ExternalGroupDto> selectByGroupUuid(@Param("groupUuid") String groupUuid);
- void deleteByGroupUuid(@Param("groupUuid") String groupUuid);
+ List<ExternalGroupDto> selectByIdentityProvider(@Param("identityProvider") String identityProvider);
+ Optional<ExternalGroupDto> selectByExternalIdAndIdentityProvider(@Param("externalId") String externalId, @Param("identityProvider") String identityProvider);
+ void deleteByGroupUuid(@Param("groupUuid") String groupUuid);
}
private final String searchText;
private final String isManagedSqlClause;
- private GroupQuery(@Nullable String searchText, @Nullable String isManagedSqlClause) {
+ GroupQuery(@Nullable String searchText, @Nullable String isManagedSqlClause) {
this.searchText = searchTextToSearchTextSql(searchText);
this.isManagedSqlClause = isManagedSqlClause;
}
<mapper namespace="org.sonar.db.user.ExternalGroupMapper">
+ <sql id="externalGroupColumns">
+ eg.group_uuid as groupUuid,
+ eg.external_group_id as external_id,
+ eg.external_identity_provider as externalIdentityProvider
+ </sql>
+
<insert id="insert" useGeneratedKeys="false" parameterType="ExternalGroup">
insert into external_groups (
group_uuid,
)
</insert>
+ <select id="selectByGroupUuid" parameterType="String" resultType="ExternalGroup">
+ SELECT
+ <include refid="externalGroupColumns"/>
+ FROM external_groups eg
+ WHERE eg.group_uuid=#{groupUuid,jdbcType=VARCHAR}
+ </select>
+
<select id="selectByIdentityProvider" parameterType="String" resultType="ExternalGroup">
SELECT
- eg.group_uuid as groupUuid,
- eg.external_group_id as external_id,
- eg.external_identity_provider as externalIdentityProvider,
+ <include refid="externalGroupColumns"/>,
g.name as name
FROM external_groups eg
LEFT JOIN groups g ON eg.group_uuid = g.uuid
WHERE eg.external_identity_provider=#{identityProvider,jdbcType=VARCHAR}
</select>
+ <select id="selectByExternalIdAndIdentityProvider" parameterType="String" resultType="ExternalGroup">
+ SELECT
+ <include refid="externalGroupColumns"/>
+ FROM external_groups eg
+ WHERE eg.external_group_id=#{externalId,jdbcType=VARCHAR}
+ AND eg.external_identity_provider=#{identityProvider,jdbcType=VARCHAR}
+ </select>
+
<delete id="deleteByGroupUuid" parameterType="String">
delete from external_groups where group_uuid = #{groupUuid, jdbcType=VARCHAR}
</delete>
db.commit();
}
+ public ExternalGroupDto insertExternalGroup(ExternalGroupDto dto) {
+ db.getDbClient().externalGroupDao().insert(db.getSession(), dto);
+ db.commit();
+ return dto;
+ }
+
public ScimGroupDto insertScimGroup(GroupDto dto) {
ScimGroupDto result = db.getDbClient().scimGroupDao().enableScimForGroup(db.getSession(), dto.getUuid());
db.commit();
return db.getDbClient().groupDao().selectByName(db.getSession(), name);
}
+ public int countAllGroups() {
+ return db.getDbClient().groupDao().countByQuery(db.getSession(), new GroupQuery(null, null));
+ }
+
+ public Optional<ExternalGroupDto> selectExternalGroupByGroupUuid(String groupUuid) {
+ return db.getDbClient().externalGroupDao().selectByGroupUuid(db.getSession(), groupUuid);
+ }
+
// GROUP MEMBERSHIP
public UserGroupDto insertMember(GroupDto group, UserDto user) {
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.usergroups.ws;
+
+import java.util.Optional;
+import org.junit.Rule;
+import org.junit.Test;
+import org.sonar.api.utils.System2;
+import org.sonar.core.util.UuidFactoryFast;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.DbTester;
+import org.sonar.db.user.ExternalGroupDto;
+import org.sonar.db.user.GroupDto;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ExternalGroupServiceIT {
+
+ private static final String GROUP_NAME = "GROUP_NAME";
+ private static final String EXTERNAL_ID = "EXTERNAL_ID";
+ private static final String EXTERNAL_IDENTITY_PROVIDER = "EXTERNAL_IDENTITY_PROVIDER";
+
+ @Rule
+ public DbTester dbTester = DbTester.create(System2.INSTANCE);
+ private final DbClient dbClient = dbTester.getDbClient();
+ private final DbSession dbSession = dbTester.getSession();
+ private final GroupService groupService = new GroupService(dbClient, UuidFactoryFast.getInstance());
+
+ private final ExternalGroupService externalGroupService = new ExternalGroupService(dbClient, groupService);
+
+ @Test
+ public void createOrUpdateExternalGroup_whenNewGroup_shouldCreateIt() {
+ externalGroupService.createOrUpdateExternalGroup(dbSession, new GroupRegistration(EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER, GROUP_NAME));
+
+ assertGroupAndExternalGroup();
+ }
+
+ @Test
+ public void createOrUpdateExternalGroup_whenExistingLocalGroup_shouldMatchAndMakeItExternal() {
+ dbTester.users().insertGroup(GROUP_NAME);
+
+ externalGroupService.createOrUpdateExternalGroup(dbSession, new GroupRegistration(EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER, GROUP_NAME));
+
+ assertThat(dbTester.users().countAllGroups()).isEqualTo(1);
+ assertGroupAndExternalGroup();
+ }
+
+ @Test
+ public void createOrUpdateExternalGroup_whenExistingExternalGroup_shouldUpdate() {
+ dbTester.users().insertDefaultGroup();
+ GroupDto existingGroupDto = dbTester.users().insertGroup(GROUP_NAME);
+ dbTester.users().insertExternalGroup(new ExternalGroupDto(existingGroupDto.getUuid(), EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER));
+
+ String updatedGroupName = "updated_" + GROUP_NAME;
+ externalGroupService.createOrUpdateExternalGroup(dbSession, new GroupRegistration(EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER, updatedGroupName));
+
+ Optional<GroupDto> groupDto = dbTester.users().selectGroup(updatedGroupName);
+ assertThat(groupDto)
+ .isPresent().get()
+ .extracting(GroupDto::getName)
+ .isEqualTo(updatedGroupName);
+ }
+
+ private void assertGroupAndExternalGroup() {
+ Optional<GroupDto> groupDto = dbTester.users().selectGroup(GROUP_NAME);
+ assertThat(groupDto)
+ .isPresent().get()
+ .extracting(GroupDto::getName).isEqualTo(GROUP_NAME);
+
+ assertThat((dbTester.users().selectExternalGroupByGroupUuid(groupDto.get().getUuid())))
+ .isPresent().get()
+ .extracting(ExternalGroupDto::externalId, ExternalGroupDto::externalIdentityProvider)
+ .containsExactly(EXTERNAL_ID, EXTERNAL_IDENTITY_PROVIDER);
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.usergroups.ws;
+
+import java.util.Optional;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.user.ExternalGroupDto;
+import org.sonar.db.user.GroupDto;
+
+public class ExternalGroupService {
+
+ private final DbClient dbClient;
+ private final GroupService groupService;
+
+ public ExternalGroupService(DbClient dbClient, GroupService groupService) {
+ this.dbClient = dbClient;
+ this.groupService = groupService;
+ }
+
+ public void createOrUpdateExternalGroup(DbSession dbSession, GroupRegistration groupRegistration) {
+ Optional<GroupDto> groupDto = retrieveGroupByItsExternalInformation(dbSession, groupRegistration);
+ if (groupDto.isPresent()) {
+ updateExternalGroup(dbSession, groupDto.get(), groupRegistration.name());
+ } else {
+ createOrMatchExistingLocalGroup(dbSession, groupRegistration);
+ }
+ }
+
+ private Optional<GroupDto> retrieveGroupByItsExternalInformation(DbSession dbSession, GroupRegistration groupRegistration) {
+ Optional<ExternalGroupDto> externalGroupDto =
+ dbClient.externalGroupDao().selectByExternalIdAndIdentityProvider(dbSession, groupRegistration.externalId(), groupRegistration.externalIdentityProvider());
+ return externalGroupDto.flatMap(existingExternalGroupDto -> Optional.ofNullable(dbClient.groupDao().selectByUuid(dbSession, existingExternalGroupDto.groupUuid())));
+ }
+
+ private void updateExternalGroup(DbSession dbSession, GroupDto groupDto, String newName) {
+ groupService.updateGroup(dbSession, groupDto, newName);
+ }
+
+ private void createOrMatchExistingLocalGroup(DbSession dbSession, GroupRegistration groupRegistration) {
+ GroupDto groupDto = findOrCreateLocalGroup(dbSession, groupRegistration);
+ createExternalGroup(dbSession, groupDto.getUuid(), groupRegistration);
+ }
+
+ private GroupDto findOrCreateLocalGroup(DbSession dbSession, GroupRegistration groupRegistration) {
+ Optional<GroupDto> groupDto = groupService.findGroup(dbSession, groupRegistration.name());
+ return groupDto.orElseGet(() -> groupService.createGroup(dbSession, groupRegistration.name(), null));
+ }
+
+ private void createExternalGroup(DbSession dbSession, String groupUuid, GroupRegistration groupRegistration) {
+ dbClient.externalGroupDao().insert(dbSession, new ExternalGroupDto(groupUuid, groupRegistration.externalId(), groupRegistration.externalIdentityProvider()));
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube
+ * Copyright (C) 2009-2023 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.usergroups.ws;
+
+public record GroupRegistration(String externalId, String externalIdentityProvider, String name) {
+}
projects / sonarqube.git / commitdiff