@Test
public void select_groups_by_query_with_global_permission() {
GroupDto group1 = groupDb.insertGroup(newGroupDto().setName("Group-1"));
GroupDto group2 = groupDb.insertGroup(newGroupDto().setName("Group-2"));
GroupDto group3 = groupDb.insertGroup(newGroupDto().setName("Group-3"));
ComponentDto project = componentDb.insertComponent(newProjectDto());
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, null);
permissionDb.addGlobalPermissionToGroup(PROVISIONING, null);
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, group1.getId());
permissionDb.addGlobalPermissionToGroup(SYSTEM_ADMIN, group3.getId());
permissionDb.addProjectPermissionToGroup(UserRole.ADMIN, group2.getId(), project.getId());
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().setPermission(SCAN_EXECUTION).build()))
.containsExactly(ANYONE, "Group-1");
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().setPermission(SYSTEM_ADMIN).build()))
.containsExactly("Group-3");
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().setPermission(PROVISIONING).build()))
.containsExactly(ANYONE);
}
@Test
public void count_groups_by_query() {
GroupDto group1 = groupDb.insertGroup(newGroupDto().setName("Group-1"));
GroupDto group2 = groupDb.insertGroup(newGroupDto().setName("Group-2"));
GroupDto group3 = groupDb.insertGroup(newGroupDto().setName("Group-3"));
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, null);
permissionDb.addGlobalPermissionToGroup(PROVISIONING, group1.getId());
assertThat(underTest.countGroupsByPermissionQuery(dbSession, PermissionQuery.builder().build()))
.isEqualTo(4);
assertThat(
underTest.countGroupsByPermissionQuery(
dbSession, PermissionQuery.builder().setPermission(PROVISIONING).build()))
.isEqualTo(1);
assertThat(
underTest.countGroupsByPermissionQuery(
dbSession, PermissionQuery.builder().withPermissionOnly().build()))
.isEqualTo(2);
assertThat(
underTest.countGroupsByPermissionQuery(
dbSession, PermissionQuery.builder().setSearchQuery("Group-").build()))
.isEqualTo(3);
assertThat(
underTest.countGroupsByPermissionQuery(
dbSession, PermissionQuery.builder().setSearchQuery("Any").build()))
.isEqualTo(1);
}
@Test
public void select_groups_by_query_with_project_permissions() {
GroupDto group1 = groupDb.insertGroup();
GroupDto group2 = groupDb.insertGroup();
GroupDto group3 = groupDb.insertGroup();
ComponentDto project = componentDb.insertComponent(newProjectDto());
ComponentDto anotherProject = componentDb.insertComponent(newProjectDto());
permissionDb.addProjectPermissionToGroup(SCAN_EXECUTION, group1.getId(), project.getId());
permissionDb.addProjectPermissionToGroup(PROVISIONING, group1.getId(), project.getId());
permissionDb.addProjectPermissionToGroup(USER, null, project.getId());
permissionDb.addProjectPermissionToGroup(SYSTEM_ADMIN, group1.getId(), anotherProject.getId());
permissionDb.addProjectPermissionToGroup(SYSTEM_ADMIN, null, anotherProject.getId());
permissionDb.addProjectPermissionToGroup(
SCAN_EXECUTION, group3.getId(), anotherProject.getId());
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, group2.getId());
PermissionQuery.Builder builderOnComponent =
PermissionQuery.builder().setComponentUuid(project.uuid());
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, builderOnComponent.withPermissionOnly().build()))
.containsOnlyOnce(group1.getName());
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, builderOnComponent.setPermission(SCAN_EXECUTION).build()))
.containsOnlyOnce(group1.getName());
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, builderOnComponent.setPermission(USER).build()))
.containsOnlyOnce(ANYONE);
}
/**
* List of user permissions ordered by alphabetical order of user names
*
* @param query non-null query including optional filters.
* @param userLogins if null, then filter on all active users. If not null, then filter on logins,
* including disabled users. Must not be empty. If not null then maximum size is {@link
* org.sonar.db.DatabaseUtils#PARTITION_SIZE_FOR_ORACLE}.
*/
public List<UserPermissionDto> select(
DbSession dbSession,
String organizationUuid,
PermissionQuery query,
@Nullable Collection<String> userLogins) {
if (userLogins != null) {
if (userLogins.isEmpty()) {
return emptyList();
}
checkArgument(
userLogins.size() <= DatabaseUtils.PARTITION_SIZE_FOR_ORACLE,
"Maximum 1'000 users are accepted");
}
RowBounds rowBounds = new RowBounds(query.getPageOffset(), query.getPageSize());
return mapper(dbSession).selectByQuery(organizationUuid, query, userLogins, rowBounds);
}
@Test
public void select_groups_by_query_does_not_return_anyone_when_group_roles_is_empty() {
GroupDto group = groupDb.insertGroup();
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().build()))
.doesNotContain(ANYONE)
.containsExactly(group.getName());
}
@Test
public void select_groups_by_query_paginated() {
IntStream.rangeClosed(0, 9)
.forEach(i -> groupDb.insertGroup(newGroupDto().setName(i + "-name")));
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().setPageIndex(2).setPageSize(3).build()))
.containsExactly("3-name", "4-name", "5-name");
}
@Test
public void select_groups_by_query_with_search_query() {
GroupDto group = groupDb.insertGroup(newGroupDto().setName("group-anyone"));
groupDb.insertGroup(newGroupDto().setName("unknown"));
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, group.getId());
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().setSearchQuery("any").build()))
.containsOnlyOnce(ANYONE, "group-anyone");
}
@Test
public void select_groups_by_query_is_ordered_by_group_names() {
groupDb.insertGroup(newGroupDto().setName("Group-2"));
groupDb.insertGroup(newGroupDto().setName("Group-3"));
groupDb.insertGroup(newGroupDto().setName("Group-1"));
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, null);
assertThat(
underTest.selectGroupNamesByPermissionQuery(
dbSession, PermissionQuery.builder().build()))
.containsExactly("Anyone", "Group-1", "Group-2", "Group-3");
}
@Test
public void select_groups_by_query() {
GroupDto group1 = groupDb.insertGroup(newGroupDto());
GroupDto group2 = groupDb.insertGroup(newGroupDto());
GroupDto group3 = groupDb.insertGroup(newGroupDto());
permissionDb.addGlobalPermissionToGroup(SCAN_EXECUTION, null);
List<String> groupNames =
underTest.selectGroupNamesByPermissionQuery(dbSession, PermissionQuery.builder().build());
assertThat(groupNames)
.containsOnly("Anyone", group1.getName(), group2.getName(), group3.getName());
}
