diff options
Diffstat (limited to 'server/sonar-db-dao/src/it/java')
26 files changed, 291 insertions, 1894 deletions
diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueDaoIT.java index df3414b2cfc..a7b9260ba8a 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueDaoIT.java @@ -42,7 +42,7 @@ import org.sonar.api.issue.Issue; import org.sonar.api.issue.impact.Severity; import org.sonar.api.issue.impact.SoftwareQuality; import org.sonar.api.rule.RuleKey; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.utils.System2; import org.sonar.db.DbSession; import org.sonar.db.DbTester; diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueMapperIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueMapperIT.java index 31bdb45c3af..2d85056e0c2 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueMapperIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/issue/IssueMapperIT.java @@ -38,7 +38,7 @@ import org.sonar.api.impl.utils.AlwaysIncreasingSystem2; import org.sonar.api.issue.Issue; import org.sonar.api.issue.impact.Severity; import org.sonar.api.issue.impact.SoftwareQuality; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.utils.DateUtils; import org.sonar.api.utils.System2; import org.sonar.core.issue.FieldDiffs; diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/AuthorizationDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/AuthorizationDaoIT.java index e7816a9c29f..1e322841762 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/AuthorizationDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/AuthorizationDaoIT.java @@ -31,7 +31,6 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; import org.sonar.core.util.Uuids; import org.sonar.db.DbSession; import org.sonar.db.DbTester; @@ -218,13 +217,13 @@ class AuthorizationDaoIT { @Test void keepAuthorizedEntityUuids_returns_empty_for_group_AnyOne_if_project_set_is_empty_on__project() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), null, ProjectPermission.USER)) .isEmpty(); } @Test void keepAuthorizedEntityUuids_returns_empty_for_user_if_project_set_is_empty_on__project() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), ProjectPermission.USER)) .isEmpty(); } @@ -234,7 +233,7 @@ class AuthorizationDaoIT { .mapToObj(i -> Integer.toString(3_562 + i)) .collect(Collectors.toSet()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomNonProjectsSet, null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomNonProjectsSet, null, ProjectPermission.USER)) .isEmpty(); } @@ -244,31 +243,31 @@ class AuthorizationDaoIT { .mapToObj(i -> Integer.toString(9_666 + i)) .collect(Collectors.toSet()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomNonProjectsSet, user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomNonProjectsSet, user.getUuid(), ProjectPermission.USER)) .isEmpty(); } @Test void keepAuthorizedEntityUuids_returns_any__project_for_group_AnyOne_without_any_permission_in_DB_and_permission_USER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, null, ProjectPermission.USER)) .containsAll(randomPublicEntityUuids); } @Test void keepAuthorizedEntityUuids_returns_any__project_for_user_without_any_permission_in_DB_and_permission_USER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, user.getUuid(), ProjectPermission.USER)) .containsAll(randomPublicEntityUuids); } @Test void keepAuthorizedEntityUuids_returns_any__project_for_group_AnyOne_without_any_permission_in_DB_and_permission_CODEVIEWER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, null, UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, null, ProjectPermission.CODEVIEWER)) .containsAll(randomPublicEntityUuids); } @Test void keepAuthorizedEntityUuids_returns_any__project_for_user_without_any_permission_in_DB_and_permission_CODEVIEWER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, user.getUuid(), UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPublicEntityUuids, user.getUuid(), ProjectPermission.CODEVIEWER)) .containsAll(randomPublicEntityUuids); } @@ -335,25 +334,25 @@ class AuthorizationDaoIT { @Test void keepAuthorizedEntityUuids_returns_empty_for_user_on_private_project_without_any_permission_in_DB_and_permission_USER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, user.getUuid(), ProjectPermission.USER)) .isEmpty(); } @Test void keepAuthorizedEntityUuids_returns_empty_for_group_AnyOne_on_private_project_without_any_permission_in_DB_and_permission_USER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, null, ProjectPermission.USER)) .isEmpty(); } @Test void keepAuthorizedEntityUuids_returns_empty_for_user_on_private_project_without_any_permission_in_DB_and_permission_CODEVIEWER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, user.getUuid(), UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, user.getUuid(), ProjectPermission.CODEVIEWER)) .isEmpty(); } @Test void keepAuthorizedEntityUuids_returns_empty_for_group_AnyOne_on_private_project_without_any_permission_in_DB_and_permission_CODEVIEWER() { - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, null, UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, randomPrivateEntityUuids, null, ProjectPermission.CODEVIEWER)) .isEmpty(); } @@ -421,20 +420,20 @@ class AuthorizationDaoIT { ProjectDto project3 = db.components().insertPrivateProject().getProjectDto(); UserDto user = db.users().insertUser("u1"); GroupDto group = db.users().insertGroup(); - db.users().insertProjectPermissionOnUser(user, UserRole.USER, project2); - db.users().insertProjectPermissionOnUser(user, UserRole.USER, project3); + db.users().insertProjectPermissionOnUser(user, ProjectPermission.USER, project2); + db.users().insertProjectPermissionOnUser(user, ProjectPermission.USER, project3); db.users().insertMember(group, user); - db.users().insertEntityPermissionOnGroup(group, UserRole.USER, project1); + db.users().insertEntityPermissionOnGroup(group, ProjectPermission.USER, project1); assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project2.getUuid(), project3.getUuid()), user.getUuid(), - UserRole.USER)) + ProjectPermission.USER)) .containsOnly(project2.getUuid(), project3.getUuid()); // user does not have the role "admin" - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project2.getUuid()), user.getUuid(), UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project2.getUuid()), user.getUuid(), ProjectPermission.ADMIN)) .isEmpty(); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), ProjectPermission.ADMIN)) .isEmpty(); } @@ -446,17 +445,17 @@ class AuthorizationDaoIT { UserDto user1 = db.users().insertUser("u1"); GroupDto group = db.users().insertGroup(); db.users().insertMembers(group, user1); - db.users().insertProjectPermissionOnUser(user1, UserRole.USER, project1); - db.users().insertEntityPermissionOnGroup(group, UserRole.USER, project2); - db.users().insertEntityPermissionOnGroup(group, UserRole.USER, project3); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.USER, project1); + db.users().insertEntityPermissionOnGroup(group, ProjectPermission.USER, project2); + db.users().insertEntityPermissionOnGroup(group, ProjectPermission.USER, project3); assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project2.getUuid(), project3.getUuid()), user1.getUuid(), - UserRole.USER)) + ProjectPermission.USER)) .containsOnly(project2.getUuid(), project3.getUuid()); // group does not have the role "admin" assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project2.getUuid(), project3.getUuid()), user1.getUuid(), - UserRole.ADMIN)) + ProjectPermission.ADMIN)) .isEmpty(); } @@ -468,7 +467,7 @@ class AuthorizationDaoIT { GroupDto group = db.users().insertGroup(); db.users().insertMembers(group, user1); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project1.getUuid(), project2.getUuid()), null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(project1.getUuid(), project2.getUuid()), null, ProjectPermission.USER)) .containsOnly(project1.getUuid(), project2.getUuid()); // group does not have the role "admin" @@ -481,7 +480,7 @@ class AuthorizationDaoIT { List<ProjectDto> projects = IntStream.range(0, 2000).mapToObj(i -> db.components().insertPublicProject().getProjectDto()).toList(); Collection<String> uuids = projects.stream().map(ProjectDto::getUuid).collect(Collectors.toSet()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, uuids, null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, uuids, null, ProjectPermission.USER)) .containsOnly(uuids.toArray(new String[0])); } @@ -489,7 +488,7 @@ class AuthorizationDaoIT { void keepAuthorizedUsersForRoleAndEntity_returns_empty_if_user_set_is_empty_on__project() { ProjectDto project = db.components().insertPublicProject().getProjectDto(); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, Collections.emptySet(), UserRole.USER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, Collections.emptySet(), ProjectPermission.USER, project.getUuid())) .isEmpty(); } @@ -501,7 +500,7 @@ class AuthorizationDaoIT { .mapToObj(i -> Uuids.createFast()) .collect(Collectors.toSet()); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomNonExistingUserUuidsSet, UserRole.USER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomNonExistingUserUuidsSet, ProjectPermission.USER, project.getUuid())) .isEmpty(); } @@ -509,7 +508,7 @@ class AuthorizationDaoIT { void keepAuthorizedUsersForRoleAndEntity_returns_any_users_for__project_without_any_permission_in_DB_and_permission_USER() { ProjectDto project = db.components().insertPublicProject().getProjectDto(); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, UserRole.USER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, ProjectPermission.USER, project.getUuid())) .containsAll(randomExistingUserUuids); } @@ -517,7 +516,7 @@ class AuthorizationDaoIT { void keepAuthorizedUsersForRoleAndEntity_returns_any_users_for__project_without_any_permission_in_DB_and_permission_CODEVIEWER() { ProjectDto project = db.components().insertPublicProject().getProjectDto(); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, UserRole.CODEVIEWER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, ProjectPermission.CODEVIEWER, project.getUuid())) .containsAll(randomExistingUserUuids); } @@ -591,7 +590,7 @@ class AuthorizationDaoIT { void keepAuthorizedUsersForRoleAndEntity_returns_empty_for_any_user_on_private_project_without_any_permission_in_DB_and_permission_USER() { ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, UserRole.USER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, ProjectPermission.USER, project.getUuid())) .isEmpty(); } @@ -599,7 +598,7 @@ class AuthorizationDaoIT { void keepAuthorizedUsersForRoleAndEntity_returns_empty_for_any_user_on_private_project_without_any_permission_in_DB_and_permission_CODEVIEWER() { ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, UserRole.CODEVIEWER, project.getUuid())) + assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, randomExistingUserUuids, ProjectPermission.CODEVIEWER, project.getUuid())) .isEmpty(); } @@ -667,10 +666,10 @@ class AuthorizationDaoIT { GroupDto group2 = db.users().insertGroup(); db.users().insertMembers(group1, user1, user2); db.users().insertMembers(group2, user3); - db.users().insertProjectPermissionOnUser(user1, UserRole.USER, project1); - db.users().insertProjectPermissionOnUser(user2, UserRole.USER, project1); - db.users().insertProjectPermissionOnUser(user3, UserRole.USER, project1); - db.users().insertEntityPermissionOnGroup(group2, UserRole.USER, project3); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.USER, project1); + db.users().insertProjectPermissionOnUser(user2, ProjectPermission.USER, project1); + db.users().insertProjectPermissionOnUser(user3, ProjectPermission.USER, project1); + db.users().insertEntityPermissionOnGroup(group2, ProjectPermission.USER, project3); assertThat(underTest.keepAuthorizedUsersForRoleAndEntity(dbSession, // Only 100 and 101 has 'user' role on project @@ -769,31 +768,31 @@ class AuthorizationDaoIT { @Test void selectEntityPermissions_returns_permissions_of_logged_in_user_on_specified_project() { ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - db.users().insertProjectPermissionOnUser(user, UserRole.CODEVIEWER, project); - db.users().insertProjectPermissionOnUser(db.users().insertUser(), UserRole.ISSUE_ADMIN, project); + db.users().insertProjectPermissionOnUser(user, ProjectPermission.CODEVIEWER, project); + db.users().insertProjectPermissionOnUser(db.users().insertUser(), ProjectPermission.ISSUE_ADMIN, project); - assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(UserRole.CODEVIEWER); + assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(ProjectPermission.CODEVIEWER.getKey()); } @Test void selectEntityPermissions_returns_permissions_of_logged_in_user_on_specified_project_through_group_membership() { ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - db.users().insertEntityPermissionOnGroup(group1, UserRole.CODEVIEWER, project); - db.users().insertEntityPermissionOnGroup(group2, UserRole.ISSUE_ADMIN, project); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.CODEVIEWER, project); + db.users().insertEntityPermissionOnGroup(group2, ProjectPermission.ISSUE_ADMIN, project); db.users().insertMember(group1, user); - assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(UserRole.CODEVIEWER); + assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(ProjectPermission.CODEVIEWER.getKey()); } @Test void selectEntityPermissions_returns_permissions_of_logged_in_user_on_specified_private_project_through_all_possible_configurations() { ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - db.users().insertProjectPermissionOnUser(user, UserRole.CODEVIEWER, project); - db.users().insertEntityPermissionOnGroup(group1, UserRole.USER, project); + db.users().insertProjectPermissionOnUser(user, ProjectPermission.CODEVIEWER, project); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.USER, project); db.users().insertMember(group1, user); - assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(UserRole.CODEVIEWER, - UserRole.USER); + assertThat(underTest.selectEntityPermissions(dbSession, project.getUuid(), user.getUuid())).containsOnly(ProjectPermission.CODEVIEWER.getKey(), + ProjectPermission.USER.getKey()); } @Test @@ -918,14 +917,14 @@ class AuthorizationDaoIT { ProjectDto privateProject = db.components().insertPrivateProject().getProjectDto(); ProjectDto Project = db.components().insertPublicProject().getProjectDto(); UserDto user = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(user, UserRole.ADMIN, privateProject); + db.users().insertProjectPermissionOnUser(user, ProjectPermission.ADMIN, privateProject); assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(privateProject.getUuid(), Project.getUuid()), user.getUuid(), - UserRole.ADMIN)) + ProjectPermission.ADMIN)) .containsOnly(privateProject.getUuid()); // user does not have the permission "issueadmin" assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(privateProject.getUuid(), Project.getUuid()), user.getUuid(), - UserRole.ISSUE_ADMIN)) + ProjectPermission.ISSUE_ADMIN)) .isEmpty(); } @@ -936,14 +935,14 @@ class AuthorizationDaoIT { UserDto user = db.users().insertUser(); GroupDto group = db.users().insertGroup(); db.users().insertMember(group, user); - db.users().insertEntityPermissionOnGroup(group, UserRole.ADMIN, privateProject); + db.users().insertEntityPermissionOnGroup(group, ProjectPermission.ADMIN, privateProject); assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(privateProject.getUuid(), Project.getUuid()), user.getUuid(), - UserRole.ADMIN)) + ProjectPermission.ADMIN)) .containsOnly(privateProject.getUuid()); // user does not have the permission "issueadmin" assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(privateProject.getUuid(), Project.getUuid()), user.getUuid(), - UserRole.ISSUE_ADMIN)) + ProjectPermission.ISSUE_ADMIN)) .isEmpty(); } @@ -952,11 +951,11 @@ class AuthorizationDaoIT { ProjectDto Project = db.components().insertPublicProject().getProjectDto(); UserDto user = db.users().insertUser(); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, Collections.emptySet(), user.getUuid(), ProjectPermission.USER)) .isEmpty(); // projects do not exist - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet("does_not_exist"), user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet("does_not_exist"), user.getUuid(), ProjectPermission.USER)) .isEmpty(); } @@ -965,7 +964,7 @@ class AuthorizationDaoIT { ProjectDto Project = db.components().insertPublicProject().getProjectDto(); UserDto user = db.users().insertUser(); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet("does_not_exist"), user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet("does_not_exist"), user.getUuid(), ProjectPermission.USER)) .isEmpty(); } @@ -975,19 +974,19 @@ class AuthorizationDaoIT { UserDto user = db.users().insertUser(); // logged-in user - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), ProjectPermission.CODEVIEWER)) .containsOnly(Project.getUuid()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), ProjectPermission.USER)) .containsOnly(Project.getUuid()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), user.getUuid(), ProjectPermission.ADMIN)) .isEmpty(); // anonymous - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, UserRole.CODEVIEWER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, ProjectPermission.CODEVIEWER)) .containsOnly(Project.getUuid()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, UserRole.USER)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, ProjectPermission.USER)) .containsOnly(Project.getUuid()); - assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedEntityUuids(dbSession, newHashSet(Project.getUuid()), null, ProjectPermission.ADMIN)) .isEmpty(); } @@ -1148,21 +1147,21 @@ class AuthorizationDaoIT { // admin with "direct" ADMIN role UserDto admin1 = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(admin1, UserRole.ADMIN, project); + db.users().insertProjectPermissionOnUser(admin1, ProjectPermission.ADMIN, project); // admin2 with ADMIN role through group UserDto admin2 = db.users().insertUser(); GroupDto adminGroup = db.users().insertGroup("ADMIN"); db.users().insertMember(adminGroup, admin2); - db.users().insertEntityPermissionOnGroup(adminGroup, UserRole.ADMIN, project); + db.users().insertEntityPermissionOnGroup(adminGroup, ProjectPermission.ADMIN, project); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin()); assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin(), admin1.getLogin(), admin2.getLogin()), - project.getKey(), UserRole.USER)) + project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin(), admin1.getLogin(), admin2.getLogin()); assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin(), admin1.getLogin(), admin2.getLogin()), - project.getKey(), UserRole.ADMIN)) + project.getKey(), ProjectPermission.ADMIN)) .containsOnly(admin1.getLogin(), admin2.getLogin()); } @@ -1172,12 +1171,12 @@ class AuthorizationDaoIT { GroupDto userGroup = db.users().insertGroup("USERS"); GroupDto adminGroup = db.users().insertGroup("ADMIN"); - db.users().insertEntityPermissionOnGroup(userGroup, UserRole.USER, project); - db.users().insertEntityPermissionOnGroup(adminGroup, UserRole.ADMIN, project); + db.users().insertEntityPermissionOnGroup(userGroup, ProjectPermission.USER, project); + db.users().insertEntityPermissionOnGroup(adminGroup, ProjectPermission.ADMIN, project); // admin with "direct" ADMIN role UserDto admin1 = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(admin1, UserRole.ADMIN, project); + db.users().insertProjectPermissionOnUser(admin1, ProjectPermission.ADMIN, project); // admin2 with ADMIN role through group UserDto admin2 = db.users().insertUser(); @@ -1185,7 +1184,7 @@ class AuthorizationDaoIT { // user1 with "direct" USER role UserDto user1 = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(user1, UserRole.USER, project); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.USER, project); // user2 with USER role through group UserDto user2 = db.users().insertUser(); @@ -1194,17 +1193,17 @@ class AuthorizationDaoIT { // user without role UserDto userWithNoRole = db.users().insertUser(); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(userWithNoRole.getLogin()), project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(userWithNoRole.getLogin()), project.getKey(), ProjectPermission.USER)) .isEmpty(); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin()); Set<String> allLogins = newHashSet(admin1.getLogin(), admin2.getLogin(), user1.getLogin(), user2.getLogin(), userWithNoRole.getLogin()); // Admin does not have the USER permission set - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin(), user2.getLogin()); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), ProjectPermission.ADMIN)) .containsOnly(admin1.getLogin(), admin2.getLogin()); } @@ -1215,12 +1214,12 @@ class AuthorizationDaoIT { GroupDto userGroup = db.users().insertGroup("USERS"); GroupDto adminGroup = db.users().insertGroup("ADMIN"); - db.users().insertEntityPermissionOnGroup(userGroup, UserRole.USER, project); - db.users().insertEntityPermissionOnGroup(adminGroup, UserRole.ADMIN, project); + db.users().insertEntityPermissionOnGroup(userGroup, ProjectPermission.USER, project); + db.users().insertEntityPermissionOnGroup(adminGroup, ProjectPermission.ADMIN, project); // admin with "direct" ADMIN role UserDto admin1 = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(admin1, UserRole.ADMIN, project); + db.users().insertProjectPermissionOnUser(admin1, ProjectPermission.ADMIN, project); // admin2 with ADMIN role through group UserDto admin2 = db.users().insertUser(); @@ -1228,7 +1227,7 @@ class AuthorizationDaoIT { // user1 with "direct" USER role UserDto user1 = db.users().insertUser(); - db.users().insertProjectPermissionOnUser(user1, UserRole.USER, project); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.USER, project); // user2 with USER role through group UserDto user2 = db.users().insertUser(); @@ -1237,17 +1236,17 @@ class AuthorizationDaoIT { // user without role UserDto userWithNoRole = db.users().insertUser(); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(userWithNoRole.getLogin()), project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(userWithNoRole.getLogin()), project.getKey(), ProjectPermission.USER)) .isEmpty(); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, newHashSet(user1.getLogin()), project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin()); Set<String> allLogins = newHashSet(admin1.getLogin(), admin2.getLogin(), user1.getLogin(), user2.getLogin(), userWithNoRole.getLogin()); // Admin does not have the USER permission set - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), UserRole.USER)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), ProjectPermission.USER)) .containsOnly(user1.getLogin(), user2.getLogin()); - assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), UserRole.ADMIN)) + assertThat(underTest.keepAuthorizedLoginsOnEntity(dbSession, allLogins, project.getKey(), ProjectPermission.ADMIN)) .containsOnly(admin1.getLogin(), admin2.getLogin()); } diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoIT.java index 9f640b326a0..04563dc062a 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoIT.java @@ -31,7 +31,6 @@ import java.util.stream.Stream; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.audit.NoOpAuditPersister; @@ -70,19 +69,19 @@ class GroupPermissionDaoIT { ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project3 = db.components().insertPrivateProject().getProjectDto(); - db.users().insertEntityPermissionOnGroup(group1, UserRole.ISSUE_ADMIN, project1); - db.users().insertEntityPermissionOnGroup(group1, UserRole.ADMIN, project2); - db.users().insertEntityPermissionOnGroup(group2, UserRole.ADMIN, project2); - db.users().insertEntityPermissionOnGroup(group3, UserRole.ADMIN, project2); - db.users().insertEntityPermissionOnGroup(group1, UserRole.USER, project2); - db.users().insertEntityPermissionOnGroup(group1, UserRole.USER, project3); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.ISSUE_ADMIN, project1); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.ADMIN, project2); + db.users().insertEntityPermissionOnGroup(group2, ProjectPermission.ADMIN, project2); + db.users().insertEntityPermissionOnGroup(group3, ProjectPermission.ADMIN, project2); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.USER, project2); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.USER, project3); final List<CountPerEntityPermission> result = new ArrayList<>(); underTest.groupsCountByComponentUuidAndPermission(dbSession, asList(project2.getUuid(), project3.getUuid(), "789"), context -> result.add(context.getResultObject())); assertThat(result).hasSize(3); - assertThat(result).extracting("permission").containsOnly(UserRole.ADMIN, UserRole.USER); + assertThat(result).extracting("permission").containsOnly(ProjectPermission.ADMIN.getKey(), ProjectPermission.USER.getKey()); assertThat(result).extracting("entityUuid").containsOnly(project2.getUuid(), project3.getUuid()); assertThat(result).extracting("count").containsOnly(3, 1); } @@ -195,7 +194,7 @@ class GroupPermissionDaoIT { db.users().insertPermissionOnAnyone(GlobalPermission.PROVISION_PROJECTS); db.users().insertPermissionOnGroup(group1, GlobalPermission.SCAN); db.users().insertPermissionOnGroup(group3, GlobalPermission.ADMINISTER); - db.users().insertEntityPermissionOnGroup(group2, UserRole.ADMIN, project); + db.users().insertEntityPermissionOnGroup(group2, ProjectPermission.ADMIN, project); assertThat(underTest.selectGroupNamesByQuery(dbSession, newQuery().setPermission(GlobalPermission.SCAN.getKey()).build())).containsExactly(ANYONE, group1.getName()); @@ -247,8 +246,8 @@ class GroupPermissionDaoIT { db.users().insertEntityPermissionOnGroup(group1, GlobalPermission.SCAN.getKey(), project); db.users().insertEntityPermissionOnGroup(group1, GlobalPermission.PROVISION_PROJECTS.getKey(), project); - db.users().insertEntityPermissionOnGroup(group1, UserRole.ADMIN, anotherProject); - db.users().insertEntityPermissionOnGroup(group3, UserRole.SCAN, anotherProject); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.ADMIN, anotherProject); + db.users().insertEntityPermissionOnGroup(group3, ProjectPermission.SCAN, anotherProject); db.users().insertPermissionOnGroup(group2, GlobalPermission.SCAN); PermissionQuery.Builder builderOnComponent = newQuery() @@ -258,7 +257,7 @@ class GroupPermissionDaoIT { assertThat(underTest.selectGroupNamesByQuery(dbSession, builderOnComponent.setPermission(GlobalPermission.SCAN.getKey()).build())).containsOnlyOnce(group1.getName()); assertThat(underTest.selectGroupNamesByQuery(dbSession, - builderOnComponent.setPermission(UserRole.USER).build())).isEmpty(); + builderOnComponent.setPermission(ProjectPermission.USER).build())).isEmpty(); } @Test @@ -297,7 +296,7 @@ class GroupPermissionDaoIT { GroupDto group2 = db.users().insertGroup("Group-2"); ProjectDto project = db.components().insertPrivateProject().getProjectDto(); - db.users().insertEntityPermissionOnGroup(group2, UserRole.ADMIN, project); + db.users().insertEntityPermissionOnGroup(group2, ProjectPermission.ADMIN, project); GroupDto group3 = db.users().insertGroup("Group-3"); db.users().insertPermissionOnGroup(group3, GlobalPermission.ADMINISTER); @@ -370,10 +369,10 @@ class GroupPermissionDaoIT { GroupDto group2 = db.users().insertGroup("Group-2"); ComponentDto project = db.components().insertPrivateProject().getMainBranchComponent(); - db.users().insertProjectPermissionOnGroup(group2, UserRole.USER, project); + db.users().insertProjectPermissionOnGroup(group2, ProjectPermission.USER, project); GroupDto group3 = db.users().insertGroup("Group-3"); - db.users().insertProjectPermissionOnGroup(group3, UserRole.USER, project); + db.users().insertProjectPermissionOnGroup(group3, ProjectPermission.USER, project); // Anyone group db.users().insertPermissionOnAnyone(GlobalPermission.SCAN); @@ -382,11 +381,11 @@ class GroupPermissionDaoIT { assertThat(underTest.selectByGroupUuids(dbSession, singletonList(group2.getUuid()), project.uuid())) .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getEntityUuid) - .containsOnly(tuple(group2.getUuid(), UserRole.USER, project.uuid())); + .containsOnly(tuple(group2.getUuid(), ProjectPermission.USER.getKey(), project.uuid())); assertThat(underTest.selectByGroupUuids(dbSession, singletonList(group3.getUuid()), project.uuid())) .extracting(GroupPermissionDto::getGroupUuid, GroupPermissionDto::getRole, GroupPermissionDto::getEntityUuid) - .containsOnly(tuple(group3.getUuid(), UserRole.USER, project.uuid())); + .containsOnly(tuple(group3.getUuid(), ProjectPermission.USER.getKey(), project.uuid())); assertThat(underTest.selectByGroupUuids(dbSession, singletonList(ANYONE_UUID), project.uuid())) .isEmpty(); @@ -527,7 +526,7 @@ class GroupPermissionDaoIT { GroupDto group = db.users().insertGroup(); db.users().insertProjectPermissionOnGroup(group, "foo", project.getMainBranchComponent()); - assertThat(underTest.selectGroupUuidsWithPermissionOnEntityBut(dbSession, "1234", UserRole.USER)) + assertThat(underTest.selectGroupUuidsWithPermissionOnEntityBut(dbSession, "1234", ProjectPermission.USER)) .isEmpty(); } diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterIT.java index e81f33a54de..51c7d24aa3d 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterIT.java @@ -38,8 +38,8 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; -import static org.sonar.api.web.UserRole.ADMIN; import static org.sonar.core.util.SequenceUuidFactory.UUID_1; +import static org.sonar.db.permission.ProjectPermission.ADMIN; class GroupPermissionDaoWithPersisterIT { private final AuditPersister auditPersister = mock(AuditPersister.class); @@ -100,7 +100,7 @@ class GroupPermissionDaoWithPersisterIT { verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); - assertNewValue(newValue, null, null, null, project.projectUuid(), null, project.projectKey(), project.getProjectDto().getName(), "TRK"); + assertNewValue(newValue, null, null, null, project.projectUuid(), (String) null, project.projectKey(), project.getProjectDto().getName(), "TRK"); assertThat(newValue).hasToString("{\"componentUuid\": \"projectUuid\", \"componentKey\": \"cKey\", \"componentName\": \"cname\", " + "\"qualifier\": \"project\" }"); } @@ -132,7 +132,7 @@ class GroupPermissionDaoWithPersisterIT { verify(auditPersister).deleteGroupPermission(eq(dbSession), newValueCaptor.capture()); newValue = newValueCaptor.getValue(); - assertNewValue(newValue, null, null, null, project.projectUuid(), null, project.projectKey(), project.getProjectDto().getName(), "TRK"); + assertNewValue(newValue, null, null, null, project.projectUuid(), (String) null, project.projectKey(), project.getProjectDto().getName(), "TRK"); assertThat(newValue).hasToString("{\"componentUuid\": \"projectUuid\", \"componentKey\": \"cKey\", " + "\"componentName\": \"cname\", \"qualifier\": \"project\" }"); } @@ -181,6 +181,12 @@ class GroupPermissionDaoWithPersisterIT { } private void assertNewValue(GroupPermissionNewValue newValue, String uuid, String groupUuid, String groupName, String cUuid, + ProjectPermission permission, + String componentKey, String cName, String qualifier) { + assertNewValue(newValue, uuid, groupUuid, groupName, cUuid, permission.getKey(), componentKey, cName, qualifier); + } + + private void assertNewValue(GroupPermissionNewValue newValue, String uuid, String groupUuid, String groupName, String cUuid, String permission, String componentKey, String cName, String qualifier) { assertThat(newValue) diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/UserPermissionDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/UserPermissionDaoIT.java index 1162a9e3778..34a7122ab06 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/UserPermissionDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/UserPermissionDaoIT.java @@ -30,7 +30,6 @@ import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; import org.sonar.core.util.Uuids; import org.sonar.db.DbSession; import org.sonar.db.DbTester; @@ -68,7 +67,7 @@ class UserPermissionDaoIT { UserPermissionDto global1 = addGlobalPermission(GlobalPermission.ADMINISTER.getKey(), user1); UserPermissionDto global2 = addGlobalPermission(GlobalPermission.ADMINISTER.getKey(), user2); UserPermissionDto global3 = addGlobalPermission(GlobalPermission.PROVISION_PROJECTS.getKey(), user2); - UserPermissionDto project1Perm = addProjectPermission(UserRole.USER, user3, project); + UserPermissionDto project1Perm = addProjectPermission(ProjectPermission.USER, user3, project); // global permissions of users who has at least one global permission, ordered by user name then permission PermissionQuery query = PermissionQuery.builder().withAtLeastOnePermission().build(); @@ -117,10 +116,10 @@ class UserPermissionDaoIT { addGlobalPermission(GlobalPermission.ADMINISTER.getKey(), user1); ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); - UserPermissionDto perm1 = addProjectPermission(UserRole.USER, user1, project1); - UserPermissionDto perm2 = addProjectPermission(UserRole.ISSUE_ADMIN, user1, project1); - UserPermissionDto perm3 = addProjectPermission(UserRole.ISSUE_ADMIN, user2, project1); - addProjectPermission(UserRole.ISSUE_ADMIN, user3, project2); + UserPermissionDto perm1 = addProjectPermission(ProjectPermission.USER, user1, project1); + UserPermissionDto perm2 = addProjectPermission(ProjectPermission.ISSUE_ADMIN, user1, project1); + UserPermissionDto perm3 = addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project1); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user3, project2); // project permissions of users who has at least one permission on this project PermissionQuery query = PermissionQuery.builder().withAtLeastOnePermission().setEntity(project1).build(); @@ -135,7 +134,7 @@ class UserPermissionDaoIT { expectPermissions(query, asList(user2.getUuid(), user1.getUuid()), perm3, perm2, perm1); // search by user name (matches 2 users) and project permission - query = PermissionQuery.builder().setSearchQuery("Mari").setPermission(UserRole.ISSUE_ADMIN).setEntity(project1).build(); + query = PermissionQuery.builder().setSearchQuery("Mari").setPermission(ProjectPermission.ISSUE_ADMIN).setEntity(project1).build(); expectPermissions(query, asList(user2.getUuid(), user1.getUuid()), perm3, perm2); // search by user name (no match) @@ -208,9 +207,9 @@ class UserPermissionDaoIT { UserDto user2 = insertUser(u -> u.setLogin("login2").setName("A").setEmail("email2@email.com")); addGlobalPermission(GlobalPermission.ADMINISTER.getKey(), user1); ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); - addProjectPermission(UserRole.USER, user2, project1); - addProjectPermission(UserRole.USER, user1, project1); - addProjectPermission(UserRole.ADMIN, user1, project1); + addProjectPermission(ProjectPermission.USER, user2, project1); + addProjectPermission(ProjectPermission.USER, user1, project1); + addProjectPermission(ProjectPermission.ADMIN, user1, project1); PermissionQuery query = PermissionQuery.builder().build(); @@ -226,24 +225,24 @@ class UserPermissionDaoIT { ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); addGlobalPermission(GlobalPermission.ADMINISTER.getKey(), user1); - addProjectPermission(UserRole.USER, user1, project1); - addProjectPermission(UserRole.ISSUE_ADMIN, user1, project1); - addProjectPermission(UserRole.ISSUE_ADMIN, user2, project1); - addProjectPermission(UserRole.ISSUE_ADMIN, user2, project2); + addProjectPermission(ProjectPermission.USER, user1, project1); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user1, project1); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project1); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project2); // no projects -> return empty list assertThat(underTest.countUsersByEntityPermission(dbSession, emptyList())).isEmpty(); // one project expectCount(singletonList(project1.getUuid()), - new CountPerEntityPermission(project1.getUuid(), UserRole.USER, 1), - new CountPerEntityPermission(project1.getUuid(), UserRole.ISSUE_ADMIN, 2)); + new CountPerEntityPermission(project1.getUuid(), ProjectPermission.USER, 1), + new CountPerEntityPermission(project1.getUuid(), ProjectPermission.ISSUE_ADMIN, 2)); // multiple projects expectCount(asList(project1.getUuid(), project2.getUuid(), "invalid"), - new CountPerEntityPermission(project1.getUuid(), UserRole.USER, 1), - new CountPerEntityPermission(project1.getUuid(), UserRole.ISSUE_ADMIN, 2), - new CountPerEntityPermission(project2.getUuid(), UserRole.ISSUE_ADMIN, 1)); + new CountPerEntityPermission(project1.getUuid(), ProjectPermission.USER, 1), + new CountPerEntityPermission(project1.getUuid(), ProjectPermission.ISSUE_ADMIN, 2), + new CountPerEntityPermission(project2.getUuid(), ProjectPermission.ISSUE_ADMIN, 1)); } @Test @@ -252,9 +251,9 @@ class UserPermissionDaoIT { UserDto user2 = insertUser(u -> u.setLogin("login2").setName("Marie").setEmail("email2@email.com")); ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); - addProjectPermission(UserRole.USER, user1, project1); - addProjectPermission(UserRole.USER, user2, project1); - addProjectPermission(UserRole.ISSUE_ADMIN, user2, project1); + addProjectPermission(ProjectPermission.USER, user1, project1); + addProjectPermission(ProjectPermission.USER, user2, project1); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project1); // logins are ordered by user name: user2 ("Marie") then user1 ("Marius") PermissionQuery query = PermissionQuery.builder().setEntity(project1).withAtLeastOnePermission().build(); @@ -285,9 +284,9 @@ class UserPermissionDaoIT { UserDto user2 = insertUser(u -> u.setLogin("login2").setName("Marie").setEmail("email2@email.com")); ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); - addProjectPermission(UserRole.USER, user1, project1); + addProjectPermission(ProjectPermission.USER, user1, project1); addGlobalPermission(GlobalPermission.PROVISION_PROJECTS.getKey(), user1); - addProjectPermission(UserRole.ISSUE_ADMIN, user2, project2); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project2); PermissionQuery query = PermissionQuery.builder().build(); List<String> result = underTest.selectUserUuidsByQueryAndScope(dbSession, query); @@ -302,9 +301,9 @@ class UserPermissionDaoIT { UserDto user2 = insertUser(u -> u.setLogin("login2").setName("Marie").setEmail("email2@email.com")); ProjectDto project1 = db.components().insertPrivateProject().getProjectDto(); ProjectDto project2 = db.components().insertPrivateProject().getProjectDto(); - addProjectPermission(UserRole.USER, user1, project1); + addProjectPermission(ProjectPermission.USER, user1, project1); addGlobalPermission(GlobalPermission.PROVISION_PROJECTS.getKey(), user1); - addProjectPermission(UserRole.ISSUE_ADMIN, user2, project2); + addProjectPermission(ProjectPermission.ISSUE_ADMIN, user2, project2); PermissionQuery query = PermissionQuery.builder() .setEntity(project1) .build(); @@ -459,7 +458,7 @@ class UserPermissionDaoIT { UserDto user = insertUser(); db.users().insertProjectPermissionOnUser(user, "foo", project.getMainBranchComponent()); - assertThat(underTest.selectUserIdsWithPermissionOnEntityBut(dbSession, "1234", UserRole.USER)) + assertThat(underTest.selectUserIdsWithPermissionOnEntityBut(dbSession, "1234", ProjectPermission.USER.getKey())) .isEmpty(); } @@ -579,7 +578,8 @@ class UserPermissionDaoIT { assertThat(underTest.selectEntityPermissionsOfUser(dbSession, user1.getUuid(), project1.projectUuid())).isEmpty(); assertThat(underTest.selectEntityPermissionsOfUser(dbSession, user2.getUuid(), project1.projectUuid())).isEmpty(); assertThat(underTest.selectEntityPermissionsOfUser(dbSession, user1.getUuid(), project2.projectUuid())).containsOnly(GlobalPermission.SCAN.getKey()); - assertThat(underTest.selectEntityPermissionsOfUser(dbSession, user2.getUuid(), project2.projectUuid())).containsOnly(GlobalPermission.SCAN.getKey(), GlobalPermission.PROVISION_PROJECTS.getKey()); + assertThat(underTest.selectEntityPermissionsOfUser(dbSession, user2.getUuid(), project2.projectUuid())).containsOnly(GlobalPermission.SCAN.getKey(), + GlobalPermission.PROVISION_PROJECTS.getKey()); deletedCount = underTest.deleteEntityPermissionOfAnyUser(dbSession, GlobalPermission.SCAN.getKey(), project2.getProjectDto()); @@ -639,6 +639,10 @@ class UserPermissionDaoIT { return dto; } + private UserPermissionDto addProjectPermission(ProjectPermission permission, UserDto user, EntityDto project) { + return addProjectPermission(permission.getKey(), user, project); + } + private UserPermissionDto addProjectPermission(String permission, UserDto user, EntityDto project) { UserPermissionDto dto = new UserPermissionDto(Uuids.create(), permission, user.getUuid(), project.getUuid()); underTest.insert(dbSession, dto, project, user, null); diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoIT.java index 382fbc885b6..4367f147b0c 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/GroupWithPermissionTemplateDaoIT.java @@ -25,7 +25,7 @@ import java.util.stream.IntStream; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; +import org.sonar.db.permission.ProjectPermission; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.permission.PermissionQuery; @@ -34,8 +34,8 @@ import org.sonar.db.user.GroupDto; import static java.util.Arrays.asList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.tuple; -import static org.sonar.api.web.UserRole.ADMIN; -import static org.sonar.api.web.UserRole.USER; +import static org.sonar.db.permission.ProjectPermission.ADMIN; +import static org.sonar.db.permission.ProjectPermission.USER; import static org.sonar.db.permission.GlobalPermission.PROVISION_PROJECTS; import static org.sonar.db.permission.PermissionQuery.DEFAULT_PAGE_SIZE; import static org.sonar.db.permission.PermissionQuery.builder; @@ -95,7 +95,7 @@ class GroupWithPermissionTemplateDaoIT { GroupDto group2 = db.users().insertGroup("B"); GroupDto group3 = db.users().insertGroup("C"); - permissionTemplateDbTester.addGroupToTemplate(template, group3, UserRole.USER); + permissionTemplateDbTester.addGroupToTemplate(template, group3, ProjectPermission.USER); PermissionQuery query = PermissionQuery.builder().build(); assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid())) @@ -108,7 +108,7 @@ class GroupWithPermissionTemplateDaoIT { IntStream.rangeClosed(1, DEFAULT_PAGE_SIZE + 1).forEach(i -> db.users().insertGroup("Group-" + i)); String lastGroupName = "Group-" + (DEFAULT_PAGE_SIZE + 1); - permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(lastGroupName).get(), UserRole.USER); + permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(lastGroupName).get(), ProjectPermission.USER); PermissionQuery query = PermissionQuery.builder().build(); assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid())) @@ -122,11 +122,11 @@ class GroupWithPermissionTemplateDaoIT { PermissionTemplateDto otherTemplate = permissionTemplateDbTester.insertTemplate(); IntStream.rangeClosed(1, DEFAULT_PAGE_SIZE + 1).forEach(i -> { GroupDto group = db.users().insertGroup("Group-" + i); - permissionTemplateDbTester.addGroupToTemplate(otherTemplate, group, UserRole.USER); + permissionTemplateDbTester.addGroupToTemplate(otherTemplate, group, ProjectPermission.USER); }); String lastGroupName = "Group-" + (DEFAULT_PAGE_SIZE + 1); - permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(lastGroupName).get(), UserRole.USER); + permissionTemplateDbTester.addGroupToTemplate(template, db.users().selectGroup(lastGroupName).get(), ProjectPermission.USER); PermissionQuery query = PermissionQuery.builder().build(); assertThat(underTest.selectGroupNamesByQueryAndTemplate(db.getSession(), query, template.getUuid())) @@ -216,8 +216,8 @@ class GroupWithPermissionTemplateDaoIT { .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getUuid(), "Group-1", USER), - tuple(group1.getUuid(), "Group-1", ADMIN)); + tuple(group1.getUuid(), "Group-1", USER.getKey()), + tuple(group1.getUuid(), "Group-1", ADMIN.getKey())); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, anotherTemplate.getUuid(), asList("Group-1"))) .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, @@ -229,7 +229,7 @@ class GroupWithPermissionTemplateDaoIT { .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple("Anyone", "Anyone", USER)); + tuple("Anyone", "Anyone", USER.getKey())); assertThat(underTest.selectGroupPermissionsByTemplateIdAndGroupNames(session, template.getUuid(), asList("Group-1", "Group-2", "Anyone"))).hasSize(3); @@ -258,15 +258,15 @@ class GroupWithPermissionTemplateDaoIT { .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( - tuple(group1.getUuid(), "Group-1", USER), - tuple(group1.getUuid(), "Group-1", ADMIN), + tuple(group1.getUuid(), "Group-1", USER.getKey()), + tuple(group1.getUuid(), "Group-1", ADMIN.getKey()), tuple(group2.getUuid(), "Group-2", PROVISION_PROJECTS.getKey())); assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, anotherTemplate.getUuid())) .extracting(PermissionTemplateGroupDto::getGroupUuid, PermissionTemplateGroupDto::getGroupName, PermissionTemplateGroupDto::getPermission) .containsOnly( tuple(group1.getUuid(), "Group-1", PROVISION_PROJECTS.getKey()), - tuple("Anyone", "Anyone", USER)); + tuple("Anyone", "Anyone", USER.getKey())); assertThat(underTest.selectGroupPermissionsByTemplateUuid(session, "321")).isEmpty(); } diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoIT.java index ed49ce3fd1c..d275eb56563 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoIT.java @@ -24,7 +24,7 @@ import java.util.Optional; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; +import org.sonar.db.permission.ProjectPermission; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.audit.NoOpAuditPersister; @@ -46,7 +46,7 @@ class PermissionTemplateCharacteristicDaoIT { void selectByTemplateId_filter_by_template_uuid() { PermissionTemplateCharacteristicDto templatePermission1 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid1") - .setPermission(UserRole.ADMIN) + .setPermission(ProjectPermission.ADMIN) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(1_000_000_000L) @@ -54,7 +54,7 @@ class PermissionTemplateCharacteristicDaoIT { "template"); PermissionTemplateCharacteristicDto templatePermission2 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid2") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("2") .setWithProjectCreator(false) .setCreatedAt(1_000_000_000L) @@ -62,7 +62,7 @@ class PermissionTemplateCharacteristicDaoIT { "template"); PermissionTemplateCharacteristicDto templatePermission3 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid3") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("3") .setWithProjectCreator(false) .setCreatedAt(1_000_000_001L) @@ -71,7 +71,7 @@ class PermissionTemplateCharacteristicDaoIT { PermissionTemplateCharacteristicDto templatePermissionForAnotherTemplate = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid4") - .setPermission(UserRole.ADMIN) + .setPermission(ProjectPermission.ADMIN) .setTemplateUuid("42") .setWithProjectCreator(true) .setCreatedAt(1_000_000_000L) @@ -99,7 +99,7 @@ class PermissionTemplateCharacteristicDaoIT { void selectByPermissionAndTemplateId() { PermissionTemplateCharacteristicDto templatePermission1 = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid1") - .setPermission(UserRole.ADMIN) + .setPermission(ProjectPermission.ADMIN) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(1_000_000_000L) @@ -107,7 +107,7 @@ class PermissionTemplateCharacteristicDaoIT { "template"); underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid2") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(false) .setCreatedAt(1_000_000_000L) @@ -115,14 +115,14 @@ class PermissionTemplateCharacteristicDaoIT { "template"); underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid3") - .setPermission(UserRole.ADMIN) + .setPermission(ProjectPermission.ADMIN) .setTemplateUuid("42") .setWithProjectCreator(true) .setCreatedAt(1_000_000_000L) .setUpdatedAt(2_000_000_000L), "template"); - Optional<PermissionTemplateCharacteristicDto> result = underTest.selectByPermissionAndTemplateId(dbSession, UserRole.ADMIN, "1"); + Optional<PermissionTemplateCharacteristicDto> result = underTest.selectByPermissionAndTemplateId(dbSession, ProjectPermission.ADMIN, "1"); assertThat(result).isPresent(); assertThat(result.get()).isEqualToComparingFieldByField(templatePermission1); @@ -132,7 +132,7 @@ class PermissionTemplateCharacteristicDaoIT { void insert() { PermissionTemplateCharacteristicDto expectedResult = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) @@ -149,7 +149,7 @@ class PermissionTemplateCharacteristicDaoIT { void update_only_change_with_project_creator_and_updated_at() { PermissionTemplateCharacteristicDto insertedDto = underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) @@ -177,7 +177,7 @@ class PermissionTemplateCharacteristicDaoIT { void fail_insert_if_created_at_is_equal_to_0() { PermissionTemplateCharacteristicDto characteristicDto = new PermissionTemplateCharacteristicDto() .setUuid("uuid") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setUpdatedAt(2_000_000_000L); @@ -189,7 +189,7 @@ class PermissionTemplateCharacteristicDaoIT { void fail_insert_if_updated_at_is_equal_to_0() { PermissionTemplateCharacteristicDto characteristicDto = new PermissionTemplateCharacteristicDto() .setUuid("uuid") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(2_000_000_000L); @@ -201,7 +201,7 @@ class PermissionTemplateCharacteristicDaoIT { @Test void fail_update_if_uuid_is_null() { PermissionTemplateCharacteristicDto characteristicDto = new PermissionTemplateCharacteristicDto() - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) @@ -214,7 +214,7 @@ class PermissionTemplateCharacteristicDaoIT { void delete_by_permission_template_uuid() { underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid1") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) @@ -222,7 +222,7 @@ class PermissionTemplateCharacteristicDaoIT { "template"); underTest.insert(dbSession, new PermissionTemplateCharacteristicDto() .setUuid("uuid2") - .setPermission(UserRole.USER) + .setPermission(ProjectPermission.USER) .setTemplateUuid("2") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoWithPersisterIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoWithPersisterIT.java index 0d35817630b..e7890b25e6c 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoWithPersisterIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateCharacteristicDaoWithPersisterIT.java @@ -23,7 +23,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.mockito.ArgumentCaptor; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; +import org.sonar.db.permission.ProjectPermission; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.audit.AuditPersister; @@ -45,7 +45,7 @@ class PermissionTemplateCharacteristicDaoWithPersisterIT { @Test void insertPermissionTemplateCharacteristicIsPersisted() { - PermissionTemplateCharacteristicDto dto = getPermissionTemplateCharacteristic(UserRole.USER); + PermissionTemplateCharacteristicDto dto = getPermissionTemplateCharacteristic(ProjectPermission.USER); underTest.insert(session, dto, "template"); verify(auditPersister).addCharacteristicToPermissionTemplate(eq(session), newValueCaptor.capture()); @@ -59,9 +59,9 @@ class PermissionTemplateCharacteristicDaoWithPersisterIT { @Test void updatePermissionTemplateCharacteristicIsPersisted() { - underTest.insert(session, getPermissionTemplateCharacteristic(UserRole.USER), + underTest.insert(session, getPermissionTemplateCharacteristic(ProjectPermission.USER), "template"); - PermissionTemplateCharacteristicDto updated = getPermissionTemplateCharacteristic(UserRole.ADMIN); + PermissionTemplateCharacteristicDto updated = getPermissionTemplateCharacteristic(ProjectPermission.ADMIN); underTest.update(session, updated, "template"); verify(auditPersister).updateCharacteristicInPermissionTemplate(eq(session), newValueCaptor.capture()); @@ -73,10 +73,10 @@ class PermissionTemplateCharacteristicDaoWithPersisterIT { assertThat(newValue.toString()).contains("withProjectCreator"); } - private PermissionTemplateCharacteristicDto getPermissionTemplateCharacteristic(String role) { + private PermissionTemplateCharacteristicDto getPermissionTemplateCharacteristic(ProjectPermission role) { return new PermissionTemplateCharacteristicDto() .setUuid("uuid") - .setPermission(role) + .setPermission(role.getKey()) .setTemplateUuid("1") .setWithProjectCreator(true) .setCreatedAt(123_456_789L) diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoIT.java index 4e5edc3d579..24dcf253be2 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoIT.java @@ -26,13 +26,13 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; import org.sonar.core.util.UuidFactory; import org.sonar.core.util.UuidFactoryFast; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.audit.NoOpAuditPersister; import org.sonar.db.permission.GlobalPermission; +import org.sonar.db.permission.ProjectPermission; import org.sonar.db.user.GroupDto; import org.sonar.db.user.UserDto; @@ -284,22 +284,22 @@ class PermissionTemplateDaoIT { GroupDto group1 = db.users().insertGroup(newGroupDto()); GroupDto group2 = db.users().insertGroup(newGroupDto()); GroupDto group3 = db.users().insertGroup(newGroupDto()); - templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), UserRole.CODEVIEWER, template1.getName(), group1.getName()); - templateDb.addGroupToTemplate(template1.getUuid(), group2.getUuid(), UserRole.CODEVIEWER, template1.getName(), group2.getName()); - templateDb.addGroupToTemplate(template1.getUuid(), group3.getUuid(), UserRole.CODEVIEWER, template1.getName(), group3.getName()); - templateDb.addGroupToTemplate(template1.getUuid(), null, UserRole.CODEVIEWER, template1.getName(), null); - templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), UserRole.ADMIN, template1.getName(), group1.getName()); - templateDb.addGroupToTemplate(template2.getUuid(), group1.getUuid(), UserRole.ADMIN, template2.getName(), group1.getName()); - templateDb.addGroupToTemplate(template4.getUuid(), group1.getUuid(), UserRole.ISSUE_ADMIN, template4.getName(), group1.getName()); + templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), ProjectPermission.CODEVIEWER, template1.getName(), group1.getName()); + templateDb.addGroupToTemplate(template1.getUuid(), group2.getUuid(), ProjectPermission.CODEVIEWER, template1.getName(), group2.getName()); + templateDb.addGroupToTemplate(template1.getUuid(), group3.getUuid(), ProjectPermission.CODEVIEWER, template1.getName(), group3.getName()); + templateDb.addGroupToTemplate(template1.getUuid(), null, ProjectPermission.CODEVIEWER, template1.getName(), null); + templateDb.addGroupToTemplate(template1.getUuid(), group1.getUuid(), ProjectPermission.ADMIN, template1.getName(), group1.getName()); + templateDb.addGroupToTemplate(template2.getUuid(), group1.getUuid(), ProjectPermission.ADMIN, template2.getName(), group1.getName()); + templateDb.addGroupToTemplate(template4.getUuid(), group1.getUuid(), ProjectPermission.ISSUE_ADMIN, template4.getName(), group1.getName()); final List<CountByTemplateAndPermissionDto> result = new ArrayList<>(); underTest.groupsCountByTemplateUuidAndPermission(dbSession, asList(template1.getUuid(), template2.getUuid(), template3.getUuid()), context -> result.add(context.getResultObject())); assertThat(result).extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateUuid, - CountByTemplateAndPermissionDto::getCount) - .containsOnly(tuple(UserRole.ADMIN, template1.getUuid(), 1), tuple(UserRole.CODEVIEWER, template1.getUuid(), 4), - tuple(UserRole.ADMIN, template2.getUuid(), 1)); + CountByTemplateAndPermissionDto::getCount) + .containsOnly(tuple(ProjectPermission.ADMIN.getKey(), template1.getUuid(), 1), tuple(ProjectPermission.CODEVIEWER.getKey(), template1.getUuid(), 4), + tuple(ProjectPermission.ADMIN.getKey(), template2.getUuid(), 1)); } @Test @@ -313,12 +313,12 @@ class PermissionTemplateDaoIT { UserDto user2 = db.users().insertUser(); UserDto user3 = db.users().insertUser(); - templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), UserRole.ADMIN, template1.getName(), user1.getLogin()); - templateDb.addUserToTemplate(template1.getUuid(), user2.getUuid(), UserRole.ADMIN, template1.getName(), user2.getLogin()); - templateDb.addUserToTemplate(template1.getUuid(), user3.getUuid(), UserRole.ADMIN, template1.getName(), user3.getLogin()); - templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), UserRole.USER, template1.getName(), user1.getLogin()); - templateDb.addUserToTemplate(template2.getUuid(), user1.getUuid(), UserRole.USER, template2.getName(), user1.getLogin()); - templateDb.addUserToTemplate(anotherTemplate.getUuid(), user1.getUuid(), UserRole.ISSUE_ADMIN, anotherTemplate.getName(), + templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), ProjectPermission.ADMIN, template1.getName(), user1.getLogin()); + templateDb.addUserToTemplate(template1.getUuid(), user2.getUuid(), ProjectPermission.ADMIN, template1.getName(), user2.getLogin()); + templateDb.addUserToTemplate(template1.getUuid(), user3.getUuid(), ProjectPermission.ADMIN, template1.getName(), user3.getLogin()); + templateDb.addUserToTemplate(template1.getUuid(), user1.getUuid(), ProjectPermission.USER, template1.getName(), user1.getLogin()); + templateDb.addUserToTemplate(template2.getUuid(), user1.getUuid(), ProjectPermission.USER, template2.getName(), user1.getLogin()); + templateDb.addUserToTemplate(anotherTemplate.getUuid(), user1.getUuid(), ProjectPermission.ISSUE_ADMIN, anotherTemplate.getName(), user1.getLogin()); final List<CountByTemplateAndPermissionDto> result = new ArrayList<>(); @@ -328,9 +328,9 @@ class PermissionTemplateDaoIT { .extracting(CountByTemplateAndPermissionDto::getPermission, CountByTemplateAndPermissionDto::getTemplateUuid, CountByTemplateAndPermissionDto::getCount) .containsExactlyInAnyOrder( - tuple(UserRole.ADMIN, template1.getUuid(), 3), - tuple(UserRole.USER, template1.getUuid(), 1), - tuple(UserRole.USER, template2.getUuid(), 1)); + tuple(ProjectPermission.ADMIN.getKey(), template1.getUuid(), 3), + tuple(ProjectPermission.USER.getKey(), template1.getUuid(), 1), + tuple(ProjectPermission.USER.getKey(), template2.getUuid(), 1)); } @Test @@ -357,21 +357,22 @@ class PermissionTemplateDaoIT { db.users().insertMember(group, user); PermissionTemplateDto template = templateDb.insertTemplate(); templateDb.addProjectCreatorToTemplate(template.getUuid(), GlobalPermission.SCAN.getKey(), template.getName()); - templateDb.addProjectCreatorToTemplate(template.getUuid(), UserRole.ADMIN, template.getName()); - templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), UserRole.USER, template.getName(), user.getLogin()); - templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), UserRole.ADMIN, template.getName(), user.getLogin()); - templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.CODEVIEWER, template.getName(), group.getName()); - templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), UserRole.ADMIN, template.getName(), group.getName()); - templateDb.addGroupToTemplate(template.getUuid(), null, UserRole.ISSUE_ADMIN, template.getName(), null); + templateDb.addProjectCreatorToTemplate(template.getUuid(), ProjectPermission.ADMIN, template.getName()); + templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), ProjectPermission.USER, template.getName(), user.getLogin()); + templateDb.addUserToTemplate(template.getUuid(), user.getUuid(), ProjectPermission.ADMIN, template.getName(), user.getLogin()); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), ProjectPermission.CODEVIEWER, template.getName(), group.getName()); + templateDb.addGroupToTemplate(template.getUuid(), group.getUuid(), ProjectPermission.ADMIN, template.getName(), group.getName()); + templateDb.addGroupToTemplate(template.getUuid(), null, ProjectPermission.ISSUE_ADMIN, template.getName(), null); List<String> resultWithUser = underTest.selectPotentialPermissionsByUserUuidAndTemplateUuid(dbSession, user.getUuid(), template.getUuid()); List<String> resultWithoutUser = underTest.selectPotentialPermissionsByUserUuidAndTemplateUuid(dbSession, null, template.getUuid()); - assertThat(resultWithUser).containsOnlyOnce(GlobalPermission.SCAN.getKey(), UserRole.ADMIN, UserRole.USER, UserRole.CODEVIEWER, - UserRole.ISSUE_ADMIN); + assertThat(resultWithUser).containsOnlyOnce(ProjectPermission.SCAN.getKey(), ProjectPermission.ADMIN.getKey(), ProjectPermission.USER.getKey(), + ProjectPermission.CODEVIEWER.getKey(), + ProjectPermission.ISSUE_ADMIN.getKey()); // only permission from anyone group - assertThat(resultWithoutUser).containsOnly(UserRole.ISSUE_ADMIN); + assertThat(resultWithoutUser).containsOnly(ProjectPermission.ISSUE_ADMIN.getKey()); } @Test diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterIT.java index b9126a5953f..6a12c5222b9 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterIT.java @@ -36,7 +36,7 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; -import static org.sonar.api.web.UserRole.ADMIN; +import static org.sonar.db.permission.ProjectPermission.ADMIN; import static org.sonar.db.permission.template.PermissionTemplateTesting.newPermissionTemplateDto; import static org.sonar.db.user.GroupTesting.newGroupDto; @@ -110,7 +110,7 @@ class PermissionTemplateDaoWithPersisterIT { assertThat(newValue) .extracting(PermissionTemplateNewValue::getTemplateUuid, PermissionTemplateNewValue::getName, PermissionTemplateNewValue::getPermission, PermissionTemplateNewValue::getUserUuid, PermissionTemplateNewValue::getUserLogin) - .containsExactly(dto.getUuid(), dto.getName(), ADMIN, user.getUuid(), user.getLogin()); + .containsExactly(dto.getUuid(), dto.getName(), ADMIN.getKey(), user.getUuid(), user.getLogin()); assertThat(newValue.toString()).doesNotContain("groupUuid"); underTest.deleteUserPermission(session, dto.getUuid(), user.getUuid(), ADMIN, dto.getName(), user.getLogin()); @@ -120,7 +120,7 @@ class PermissionTemplateDaoWithPersisterIT { assertThat(newValue) .extracting(PermissionTemplateNewValue::getTemplateUuid, PermissionTemplateNewValue::getName, PermissionTemplateNewValue::getPermission, PermissionTemplateNewValue::getUserUuid, PermissionTemplateNewValue::getUserLogin) - .containsExactly(dto.getUuid(), dto.getName(), ADMIN, user.getUuid(), user.getLogin()); + .containsExactly(dto.getUuid(), dto.getName(), ADMIN.getKey(), user.getUuid(), user.getLogin()); assertThat(newValue.toString()).doesNotContain("groupUuid"); } @@ -166,7 +166,7 @@ class PermissionTemplateDaoWithPersisterIT { assertThat(newValue) .extracting(PermissionTemplateNewValue::getTemplateUuid, PermissionTemplateNewValue::getName, PermissionTemplateNewValue::getPermission, PermissionTemplateNewValue::getGroupUuid, PermissionTemplateNewValue::getGroupName) - .containsExactly(dto.getUuid(), dto.getName(), ADMIN, group.getUuid(), group.getName()); + .containsExactly(dto.getUuid(), dto.getName(), ADMIN.getKey(), group.getUuid(), group.getName()); assertThat(newValue.toString()).contains("groupUuid"); underTest.deleteGroupPermission(session, dto.getUuid(), group.getUuid(), ADMIN, dto.getName(), group.getName()); @@ -176,7 +176,7 @@ class PermissionTemplateDaoWithPersisterIT { assertThat(newValue) .extracting(PermissionTemplateNewValue::getTemplateUuid, PermissionTemplateNewValue::getName, PermissionTemplateNewValue::getPermission, PermissionTemplateNewValue::getGroupUuid, PermissionTemplateNewValue::getGroupName) - .containsExactly(dto.getUuid(), dto.getName(), ADMIN, group.getUuid(), group.getName()); + .containsExactly(dto.getUuid(), dto.getName(), ADMIN.getKey(), group.getUuid(), group.getName()); assertThat(newValue.toString()).contains("groupUuid"); } @@ -206,7 +206,7 @@ class PermissionTemplateDaoWithPersisterIT { assertThat(newValue) .extracting(PermissionTemplateNewValue::getTemplateUuid, PermissionTemplateNewValue::getName, PermissionTemplateNewValue::getPermission, PermissionTemplateNewValue::getGroupUuid, PermissionTemplateNewValue::getGroupName) - .containsExactly(templateDto.getUuid(), templateDto.getName(), ADMIN, templateGroupDto.getGroupUuid(), + .containsExactly(templateDto.getUuid(), templateDto.getName(), ADMIN.getKey(), templateGroupDto.getGroupUuid(), templateGroupDto.getGroupName()); assertThat(newValue.toString()).doesNotContain("userUuid"); diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/UserWithPermissionTemplateDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/UserWithPermissionTemplateDaoIT.java index 3916abc3e51..e85669305e0 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/UserWithPermissionTemplateDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/permission/template/UserWithPermissionTemplateDaoIT.java @@ -24,7 +24,7 @@ import java.util.stream.IntStream; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; +import org.sonar.db.permission.ProjectPermission; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.permission.PermissionQuery; @@ -34,9 +34,9 @@ import static java.util.Arrays.asList; import static java.util.Collections.singletonList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.tuple; -import static org.sonar.api.web.UserRole.ADMIN; -import static org.sonar.api.web.UserRole.CODEVIEWER; -import static org.sonar.api.web.UserRole.USER; +import static org.sonar.db.permission.ProjectPermission.ADMIN; +import static org.sonar.db.permission.ProjectPermission.CODEVIEWER; +import static org.sonar.db.permission.ProjectPermission.USER; import static org.sonar.db.permission.PermissionQuery.DEFAULT_PAGE_SIZE; import static org.sonar.db.permission.PermissionQuery.builder; @@ -140,7 +140,7 @@ class UserWithPermissionTemplateDaoIT { UserDto user1 = db.users().insertUser(u -> u.setName("A")); UserDto user2 = db.users().insertUser(u -> u.setName("B")); UserDto user3 = db.users().insertUser(u -> u.setName("C")); - db.permissionTemplates().addUserToTemplate(template.getUuid(), user3.getUuid(), UserRole.USER, template.getName(), user3.getLogin()); + db.permissionTemplates().addUserToTemplate(template.getUuid(), user3.getUuid(), ProjectPermission.USER, template.getName(), user3.getLogin()); PermissionQuery query = PermissionQuery.builder().build(); assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getUuid())) @@ -154,10 +154,10 @@ class UserWithPermissionTemplateDaoIT { PermissionTemplateDto otherTemplate = db.permissionTemplates().insertTemplate(); IntStream.rangeClosed(1, DEFAULT_PAGE_SIZE + 1).forEach(i -> { UserDto user = db.users().insertUser("User-" + i); - db.permissionTemplates().addUserToTemplate(otherTemplate, user, UserRole.USER); + db.permissionTemplates().addUserToTemplate(otherTemplate, user, ProjectPermission.USER); }); String lastLogin = "User-" + (DEFAULT_PAGE_SIZE + 1); - db.permissionTemplates().addUserToTemplate(template, db.users().selectUserByLogin(lastLogin).get(), UserRole.USER); + db.permissionTemplates().addUserToTemplate(template, db.users().selectUserByLogin(lastLogin).get(), ProjectPermission.USER); PermissionQuery query = PermissionQuery.builder().build(); assertThat(underTest.selectUserLoginsByQueryAndTemplate(db.getSession(), query, template.getUuid())) @@ -219,18 +219,18 @@ class UserWithPermissionTemplateDaoIT { singletonList(user1.getLogin()))) .extracting(PermissionTemplateUserDto::getUserLogin, PermissionTemplateUserDto::getPermission) .containsExactlyInAnyOrder( - tuple(user1.getLogin(), USER), - tuple(user1.getLogin(), ADMIN), - tuple(user1.getLogin(), CODEVIEWER)); + tuple(user1.getLogin(), USER.getKey()), + tuple(user1.getLogin(), ADMIN.getKey()), + tuple(user1.getLogin(), CODEVIEWER.getKey())); assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), asList(user1.getLogin(), user2.getLogin(), user2.getLogin()))) .extracting(PermissionTemplateUserDto::getUserLogin, PermissionTemplateUserDto::getPermission) .containsExactlyInAnyOrder( - tuple(user1.getLogin(), USER), - tuple(user1.getLogin(), ADMIN), - tuple(user1.getLogin(), CODEVIEWER), - tuple(user2.getLogin(), USER)); + tuple(user1.getLogin(), USER.getKey()), + tuple(user1.getLogin(), ADMIN.getKey()), + tuple(user1.getLogin(), CODEVIEWER.getKey()), + tuple(user2.getLogin(), USER.getKey())); assertThat(underTest.selectUserPermissionsByTemplateIdAndUserLogins(dbSession, permissionTemplate.getUuid(), singletonList("unknown"))).isEmpty(); diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/project/ProjectExportDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/project/ProjectExportDaoIT.java index f6b00f3c515..4bf4c263fef 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/project/ProjectExportDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/project/ProjectExportDaoIT.java @@ -34,7 +34,7 @@ import org.sonar.api.issue.Issue; import org.sonar.api.rule.RuleKey; import org.sonar.api.rule.RuleStatus; import org.sonar.api.rule.Severity; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.utils.System2; import org.sonar.db.DbTester; import org.sonar.db.component.BranchDto; diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/purge/PurgeDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/purge/PurgeDaoIT.java index 7f3905764e1..589145c220f 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/purge/PurgeDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/purge/PurgeDaoIT.java @@ -29,7 +29,9 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Date; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.Random; import java.util.Set; @@ -89,10 +91,6 @@ import org.sonar.db.property.PropertyDto; import org.sonar.db.report.ReportScheduleDto; import org.sonar.db.report.ReportSubscriptionDto; import org.sonar.db.rule.RuleDto; -import org.sonar.db.sca.ScaDependenciesDbTester; -import org.sonar.db.sca.ScaIssueReleaseDto; -import org.sonar.db.sca.ScaReleasesDbTester; -import org.sonar.db.sca.ScaSeverity; import org.sonar.db.source.FileSourceDto; import org.sonar.db.user.UserDismissedMessageDto; import org.sonar.db.user.UserDto; @@ -140,6 +138,7 @@ class PurgeDaoIT { private final LogTesterJUnit5 logTester = new LogTesterJUnit5(); private final DbClient dbClient = db.getDbClient(); private final DbSession dbSession = db.getSession(); + private final PurgeDao underTest = db.getDbClient().purgeDao(); @Test @@ -1964,38 +1963,57 @@ oldCreationDate)); } + private <K, V> Map<K, V> merge(Map<? extends K, ? extends V> map1, Map<? extends K, ? extends V> map2) { + Map<K, V> result = new HashMap<>(map1); + result.putAll(map2); + return result; + } + + // the SCA mappers are in an extension, so we have to use direct sql here. + // A cleaner approach would be to allow extensions to add purge logic on branch + // deletion and remove SCA knowledge from the core PurgeMapper. + private void insertScaData(String branch1Uuid, String branch2Uuid) { + var releaseBase = Map.of("package_url", "purl1", + "package_manager", "MAVEN", + "package_name", "whatever", + "version", "1.0", + "license_expression", "MIT", + "known", true, + "created_at", 0L, "updated_at", 0L); + db.executeInsert("sca_releases", merge(releaseBase, Map.of("uuid", "release-uuid1", "component_uuid", branch1Uuid))); + db.executeInsert("sca_releases", merge(releaseBase, Map.of("uuid", "release-uuid2", "component_uuid", branch2Uuid))); + assertThat(db.countRowsOfTable(dbSession, "sca_releases")).isEqualTo(2); + + var dependencyBase = Map.of("created_at", 0L, "updated_at", 0L, + "direct", true, "scope", "compile", "new_in_pull_request", true); + db.executeInsert("sca_dependencies", merge(dependencyBase, Map.of("uuid", "dependency-uuid1", "sca_release_uuid", "release-uuid1"))); + db.executeInsert("sca_dependencies", merge(dependencyBase, Map.of("uuid", "dependency-uuid2", "sca_release_uuid", "release-uuid2"))); + assertThat(db.countRowsOfTable(dbSession, "sca_dependencies")).isEqualTo(2); + + // the issue uuids here don't even exist but doesn't matter, we don't delete issues so not testing that + var issueReleaseBase = Map.of("created_at", 0L, "updated_at", 0L, + "severity", "INFO", "severity_sort_key", 42); + db.executeInsert("sca_issues_releases", merge(issueReleaseBase, Map.of("uuid", "issue-release-uuid1", + "sca_issue_uuid", "issue-uuid1", "sca_release_uuid", "release-uuid1"))); + db.executeInsert("sca_issues_releases", merge(issueReleaseBase, Map.of("uuid", "issue-release-uuid2", + "sca_issue_uuid", "issue-uuid2", "sca_release_uuid", "release-uuid2"))); + + assertThat(db.countRowsOfTable(dbSession, "sca_issues_releases")).isEqualTo(2); + } + @Test void deleteBranch_purgesScaActivity() { ProjectDto project = db.components().insertPublicProject().getProjectDto(); BranchDto branch1 = db.components().insertProjectBranch(project); BranchDto branch2 = db.components().insertProjectBranch(project); - ScaReleasesDbTester scaReleasesDbTester = new ScaReleasesDbTester(db); - var release1 = scaReleasesDbTester.insertScaRelease(branch1.getUuid(), "1"); - var release2 = scaReleasesDbTester.insertScaRelease(branch2.getUuid(), "2"); - - ScaDependenciesDbTester scaDependenciesDbTester = new ScaDependenciesDbTester(db); - scaDependenciesDbTester.insertScaDependency(release1.uuid(), "1"); - scaDependenciesDbTester.insertScaDependency(release2.uuid(), "2"); - - ScaIssueReleaseDto issueRelease1 = new ScaIssueReleaseDto.Builder().setUuid("foo1").setScaIssueUuid("baz").setSeverity(ScaSeverity.LOW).setScaReleaseUuid(release1.uuid()).build(); - ScaIssueReleaseDto issueRelease2 = new ScaIssueReleaseDto.Builder().setUuid("foo2").setScaIssueUuid("baz").setSeverity(ScaSeverity.LOW).setScaReleaseUuid(release2.uuid()).build(); - dbClient.scaIssuesReleasesDao().insert(dbSession, issueRelease1); - dbClient.scaIssuesReleasesDao().insert(dbSession, issueRelease2); - - assertThat(dbClient.scaReleasesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isNotEmpty(); - assertThat(dbClient.scaDependenciesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isNotEmpty(); - assertThat(dbClient.scaIssuesReleasesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isNotEmpty(); + insertScaData(branch1.getUuid(), branch2.getUuid()); underTest.deleteBranch(dbSession, branch1.getUuid()); - assertThat(dbClient.scaReleasesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isEmpty(); - assertThat(dbClient.scaDependenciesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isEmpty(); - assertThat(dbClient.scaIssuesReleasesDao().selectByBranchUuid(dbSession, branch1.getUuid())).isEmpty(); - - assertThat(dbClient.scaReleasesDao().selectByBranchUuid(dbSession, branch2.getUuid())).isNotEmpty(); - assertThat(dbClient.scaDependenciesDao().selectByBranchUuid(dbSession, branch2.getUuid())).isNotEmpty(); - assertThat(dbClient.scaIssuesReleasesDao().selectByBranchUuid(dbSession, branch2.getUuid())).isNotEmpty(); + assertThat(db.countRowsOfTable(dbSession, "sca_releases")).isEqualTo(1); + assertThat(db.countRowsOfTable(dbSession, "sca_dependencies")).isEqualTo(1); + assertThat(db.countRowsOfTable(dbSession, "sca_issues_releases")).isEqualTo(1); } private AnticipatedTransitionDto getAnticipatedTransitionsDto(String uuid, String projectUuid, Date creationDate) { diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java index 033ba5daa9f..f15bbf5cc1c 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java @@ -33,7 +33,7 @@ import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.impl.utils.TestSystem2; import org.sonar.api.issue.impact.SoftwareQuality; import org.sonar.api.rule.Severity; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.server.rule.RuleParamType; import org.sonar.api.utils.System2; import org.sonar.db.DbSession; diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/QualityProfileExportDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/QualityProfileExportDaoIT.java index 3b7f50942fa..be6d177fb98 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/QualityProfileExportDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/QualityProfileExportDaoIT.java @@ -31,7 +31,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.impl.utils.AlwaysIncreasingSystem2; import org.sonar.api.rule.RuleStatus; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.db.DbSession; import org.sonar.db.DbTester; import org.sonar.db.rule.RuleDto; @@ -97,7 +97,7 @@ class QualityProfileExportDaoIT { assertThat(exportCustomRuleDto.getExtendedDescription()).isEqualTo(customRule.getNoteData()); assertThat(exportCustomRuleDto.getName()).isEqualTo(customRule.getName()); assertThat(exportCustomRuleDto.getRuleKey()).isEqualTo(customRule.getKey()); - assertThat(exportCustomRuleDto.getRuleType()).isEqualTo(RuleType.valueOf(customRule.getType())); + assertThat(exportCustomRuleDto.getRuleType()).isEqualTo(RuleType.fromDbConstant(customRule.getType())); assertThat(exportCustomRuleDto.getTags()).isEqualTo(customRule.getTags()); assertThat(exportCustomRuleDto.getTemplateRuleKey()).isEqualTo(ruleTemplate.getKey()); @@ -115,7 +115,7 @@ class QualityProfileExportDaoIT { assertThat(exportRuleDto.getExtendedDescription()).isEqualTo(rule.getNoteData()); assertThat(exportRuleDto.getName()).isEqualTo(rule.getName()); assertThat(exportRuleDto.getRuleKey()).isEqualTo(rule.getKey()); - assertThat(exportRuleDto.getRuleType()).isEqualTo(RuleType.valueOf(rule.getType())); + assertThat(exportRuleDto.getRuleType()).isEqualTo(RuleType.fromDbConstant(rule.getType())); ActiveRuleDto activeRule = activeRules.stream().filter(activeRuleDto -> activeRuleDto.getRuleKey().equals(rule.getKey())).findFirst().get(); diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/report/RegulatoryReportDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/report/RegulatoryReportDaoIT.java index 7eb2bc34250..3b3d9ca49cc 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/report/RegulatoryReportDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/report/RegulatoryReportDaoIT.java @@ -26,7 +26,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.api.issue.impact.Severity; import org.sonar.api.issue.impact.SoftwareQuality; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.utils.System2; import org.sonar.db.DbTester; import org.sonar.db.component.ComponentDto; diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/rule/RuleDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/rule/RuleDaoIT.java index 26f799fa610..cb66d99fc6b 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/rule/RuleDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/rule/RuleDaoIT.java @@ -41,7 +41,7 @@ import org.sonar.api.rule.RuleStatus; import org.sonar.api.rule.Severity; import org.sonar.api.rules.CleanCodeAttribute; import org.sonar.api.rules.RuleQuery; -import org.sonar.api.rules.RuleType; +import org.sonar.core.rule.RuleType; import org.sonar.api.server.debt.DebtRemediationFunction; import org.sonar.api.utils.DateUtils; import org.sonar.api.utils.System2; @@ -1157,7 +1157,7 @@ class RuleDaoIT { assertThat(ruleForIndexing.getInternalKey()).isEqualTo(r1.getConfigKey()); assertThat(ruleForIndexing.getLanguage()).isEqualTo(r1.getLanguage()); assertThat(ruleForIndexing.getType()).isEqualTo(r1.getType()); - assertThat(ruleForIndexing.getTypeAsRuleType()).isEqualTo(RuleType.valueOf(r1.getType())); + assertThat(ruleForIndexing.getTypeAsRuleType()).isEqualTo(RuleType.fromDbConstant(r1.getType())); assertThat(ruleForIndexing.getCreatedAt()).isEqualTo(r1.getCreatedAt()); assertThat(ruleForIndexing.getUpdatedAt()).isEqualTo(r1.getUpdatedAt()); } diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaDependenciesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaDependenciesDaoIT.java deleted file mode 100644 index 99c028718ef..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaDependenciesDaoIT.java +++ /dev/null @@ -1,248 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; -import org.sonar.db.Pagination; -import org.sonar.db.component.ComponentDto; -import org.sonar.db.component.ProjectData; - -import static org.assertj.core.api.Assertions.assertThat; - -class ScaDependenciesDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaDependenciesDao scaDependenciesDao = db.getDbClient().scaDependenciesDao(); - - @Test - void insert_shouldPersistScaDependencies() { - ScaDependencyDto scaDependencyDto = db.getScaDependenciesDbTester().insertScaDependency("scaReleaseUuid", "1"); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_dependencies"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", scaDependencyDto.uuid()), - Map.entry("sca_release_uuid", scaDependencyDto.scaReleaseUuid()), - Map.entry("direct", scaDependencyDto.direct()), - Map.entry("scope", scaDependencyDto.scope()), - Map.entry("user_dependency_file_path", scaDependencyDto.userDependencyFilePath()), - Map.entry("lockfile_dependency_file_path", scaDependencyDto.lockfileDependencyFilePath()), - Map.entry("chains", scaDependencyDto.getChainsJson()), - Map.entry("new_in_pull_request", scaDependencyDto.newInPullRequest()), - Map.entry("production_scope", scaDependencyDto.productionScope()), - Map.entry("created_at", scaDependencyDto.createdAt()), - Map.entry("updated_at", scaDependencyDto.updatedAt()))); - } - - @Test - void deleteByUuid_shouldDeleteScaDependencies() { - ScaDependencyDto scaDependencyDto = db.getScaDependenciesDbTester().insertScaDependency("scaReleaseUuid", "1"); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_dependencies"); - assertThat(select).isNotEmpty(); - - scaDependenciesDao.deleteByUuid(db.getSession(), scaDependencyDto.uuid()); - - select = db.select(db.getSession(), "select * from sca_dependencies"); - assertThat(select).isEmpty(); - } - - @Test - void selectByUuid_shouldLoadScaDependency() { - ScaDependencyDto scaDependencyDto = db.getScaDependenciesDbTester().insertScaDependency("scaReleaseUuid", "1"); - - var loadedOptional = scaDependenciesDao.selectByUuid(db.getSession(), scaDependencyDto.uuid()); - - assertThat(loadedOptional).contains(scaDependencyDto); - } - - @Test - void selectByReleaseUuids_shouldReturnScaDependencies() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1a = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1a", true, PackageManager.MAVEN, "foo.bar1"); - // same release, different dependency - ScaDependencyDto scaDependencyDto1b = db.getScaDependenciesDbTester().insertScaDependency(scaDependencyDto1a.scaReleaseUuid(), "1b", false); - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", true, PackageManager.MAVEN, "foo.bar2"); - ScaDependencyDto scaDependencyDto3 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "3", true, PackageManager.MAVEN, "foo.bar3"); - - List<ScaDependencyDto> results = scaDependenciesDao.selectByReleaseUuids(db.getSession(), List.of(scaDependencyDto1a.scaReleaseUuid(), scaDependencyDto2.scaReleaseUuid())); - - assertThat(results) - .containsExactlyInAnyOrder(scaDependencyDto1a, scaDependencyDto1b, scaDependencyDto2) - .doesNotContain(scaDependencyDto3); - } - - @Test - void selectByQuery_shouldReturnScaDependencies_whenQueryByBranchUuid() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - // same release, different dependency - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependency(scaDependencyDto1.scaReleaseUuid(), "2", false); - - ScaDependenciesQuery scaDependenciesQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, null, null); - List<ScaDependencyDto> results = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesQuery, Pagination.all()); - - assertThat(results).containsExactlyInAnyOrder(scaDependencyDto1, scaDependencyDto2); - } - - @Test - void selectByQuery_shouldReturnPaginatedScaDependencies() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", true, PackageManager.MAVEN, "foo.bar"); - ScaDependencyDto scaDependencyDto3 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "3", true, PackageManager.MAVEN, "something"); - ScaDependencyDto scaDependencyDto4 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "4", true, PackageManager.MAVEN, "something-else"); - - ScaDependenciesQuery scaDependenciesQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, null, null); - List<ScaDependencyDto> page1Results = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesQuery, Pagination.forPage(1).andSize(2)); - List<ScaDependencyDto> page2Results = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesQuery, Pagination.forPage(2).andSize(2)); - - // we order by uuid, so order is not meaningful here - var allResults = new ArrayList<>(page1Results); - allResults.addAll(page2Results); - assertThat(allResults).containsExactlyInAnyOrder(scaDependencyDto1, scaDependencyDto2, scaDependencyDto3, scaDependencyDto4); - assertThat(List.of(page1Results.size(), page2Results.size())).containsExactly(2, 2); - } - - @Test - void selectByQuery_shouldPartiallyMatchPackageName_whenQueriedByText() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - @SuppressWarnings("unused") - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", true, PackageManager.MAVEN, "bar.mee"); - ScaDependencyDto scaDependencyDto3 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "3", true, PackageManager.MAVEN, "foo.bar.me"); - @SuppressWarnings("unused") - ScaDependencyDto scaDependencyDto4 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "4", true, PackageManager.MAVEN, "some.foo.bar"); - - ScaDependenciesQuery scaDependenciesQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, null, "foo.bar"); - List<ScaDependencyDto> results = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesQuery, Pagination.all()); - - assertThat(results).hasSize(2); - assertThat(results.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto1); - assertThat(results.get(1)).usingRecursiveComparison().isEqualTo(scaDependencyDto3); - - ScaDependenciesQuery scaDependenciesCaseInsensitiveQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, null, "Foo.Bar"); - List<ScaDependencyDto> resultsCaseInsensitive = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesCaseInsensitiveQuery, Pagination.all()); - - assertThat(resultsCaseInsensitive).hasSize(2); - assertThat(resultsCaseInsensitive.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto1); - assertThat(resultsCaseInsensitive.get(1)).usingRecursiveComparison().isEqualTo(scaDependencyDto3); - } - - @Test - void selectByQuery_shouldReturnScaDependencies_whenQueryByDirect() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", false, PackageManager.MAVEN, "foo.bar"); - - ScaDependenciesQuery scaDependenciesDirectQuery = new ScaDependenciesQuery(componentDto.branchUuid(), true, null, null); - List<ScaDependencyDto> resultsDirect = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesDirectQuery, Pagination.all()); - - assertThat(resultsDirect).hasSize(1); - assertThat(resultsDirect.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto1); - - ScaDependenciesQuery scaDependenciesNoDirectQuery = new ScaDependenciesQuery(componentDto.branchUuid(), false, null, null); - List<ScaDependencyDto> resultsNoDirect = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesNoDirectQuery, Pagination.all()); - - assertThat(resultsNoDirect).hasSize(1); - assertThat(resultsNoDirect.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto2); - } - - @Test - void selectByQuery_shouldReturnScaDependencies_whenQueryByPackageManager() { - ComponentDto componentDto = prepareComponentDto(); - ScaDependencyDto scaDependencyDto1 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", true, PackageManager.NPM, "foo.bar"); - ScaDependencyDto scaDependencyDto3 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "3", true, PackageManager.CARGO, "foo.bar"); - - ScaDependenciesQuery scaDependenciesMavenQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, List.of(PackageManager.MAVEN.name()), null); - List<ScaDependencyDto> resultsMaven = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesMavenQuery, Pagination.all()); - - assertThat(resultsMaven).hasSize(1); - assertThat(resultsMaven.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto1); - - ScaDependenciesQuery scaDependenciesNpmAndCargoQuery = new ScaDependenciesQuery(componentDto.branchUuid(), null, - List.of(PackageManager.NPM.name(), PackageManager.CARGO.name()), null); - List<ScaDependencyDto> resultsNpm = scaDependenciesDao.selectByQuery(db.getSession(), scaDependenciesNpmAndCargoQuery, Pagination.all()); - - assertThat(resultsNpm).hasSize(2); - assertThat(resultsNpm.get(0)).usingRecursiveComparison().isEqualTo(scaDependencyDto2); - assertThat(resultsNpm.get(1)).usingRecursiveComparison().isEqualTo(scaDependencyDto3); - } - - @Test - void update_shouldUpdateScaDependency() { - ScaDependencyDto scaDependencyDto = db.getScaDependenciesDbTester().insertScaDependency("scaReleaseUuid", "1", true); - ScaDependencyDto updatedScaDependency = scaDependencyDto.toBuilder() - .setUpdatedAt(scaDependencyDto.updatedAt() + 1) - .setDirect(!scaDependencyDto.direct()) - .setLockfileDependencyFilePath("lockfile2") - .setProductionScope(!scaDependencyDto.productionScope()) - .build(); - - scaDependenciesDao.update(db.getSession(), updatedScaDependency); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_dependencies"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", updatedScaDependency.uuid()), - Map.entry("sca_release_uuid", updatedScaDependency.scaReleaseUuid()), - Map.entry("direct", updatedScaDependency.direct()), - Map.entry("scope", updatedScaDependency.scope()), - Map.entry("user_dependency_file_path", updatedScaDependency.userDependencyFilePath()), - Map.entry("lockfile_dependency_file_path", updatedScaDependency.lockfileDependencyFilePath()), - Map.entry("chains", updatedScaDependency.getChainsJson()), - Map.entry("new_in_pull_request", updatedScaDependency.newInPullRequest()), - Map.entry("production_scope", updatedScaDependency.productionScope()), - Map.entry("created_at", updatedScaDependency.createdAt()), - Map.entry("updated_at", updatedScaDependency.updatedAt()))); - } - - @Test - void countByQuery_shouldReturnTheTotalOfDependencies() { - ComponentDto componentDto1 = prepareComponentDto(); - db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto1.uuid(), "1", true, PackageManager.MAVEN, "foo.bar"); - db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto1.uuid(), "2", true, PackageManager.MAVEN, "foo.bar.mee"); - db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto1.uuid(), "3", true, PackageManager.MAVEN, "bar.foo"); - - ScaDependenciesQuery scaDependenciesQuery = new ScaDependenciesQuery(componentDto1.branchUuid(), null, null, "foo"); - - assertThat(scaDependenciesDao.countByQuery(db.getSession(), scaDependenciesQuery)).isEqualTo(2); - assertThat(scaDependenciesDao.countByQuery(db.getSession(), new ScaDependenciesQuery(componentDto1.branchUuid(), null, null, null))).isEqualTo(3); - assertThat(scaDependenciesDao.countByQuery(db.getSession(), new ScaDependenciesQuery("another_branch_uuid", null, null, null))).isZero(); - } - - private ComponentDto prepareComponentDto() { - ProjectData projectData = db.components().insertPublicProject(); - return projectData.getMainBranchComponent(); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesDaoIT.java deleted file mode 100644 index a13fa082603..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesDaoIT.java +++ /dev/null @@ -1,134 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.util.List; -import java.util.Map; -import org.apache.ibatis.exceptions.PersistenceException; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; - -class ScaIssuesDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaIssuesDao scaIssuesDao = db.getDbClient().scaIssuesDao(); - - private static final ScaIssueDto newScaIssueDto(String suffix) { - return new ScaIssueDto("uuid" + suffix, ScaIssueType.PROHIBITED_LICENSE, "fakePackageUrl" + suffix, "fakeVulnerabilityId" + suffix, "fakeSpdxId" + suffix, 1L, 2L); - } - - @Test - void insert_shouldPersistScaIssues() { - ScaIssueDto issueDto = newScaIssueDto("1"); - scaIssuesDao.insert(db.getSession(), issueDto); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_issues"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", issueDto.uuid()), - Map.entry("sca_issue_type", issueDto.scaIssueType().name()), - Map.entry("package_url", issueDto.packageUrl()), - Map.entry("vulnerability_id", issueDto.vulnerabilityId()), - Map.entry("spdx_license_id", issueDto.spdxLicenseId()), - Map.entry("created_at", issueDto.createdAt()), - Map.entry("updated_at", issueDto.updatedAt()))); - } - - // Postgresql apparently doesn't support doing anything else in the session - // after a statement with an error (constraint violation), while other - // databases do. So we use a dedicated session here. - private void insertAndCommit(ScaIssueDto issueDto) { - try (var dbSession = db.getDbClient().openSession(false)) { - scaIssuesDao.insert(dbSession, issueDto); - dbSession.commit(true); - } - } - - @Test - void insert_shouldFailOnDuplicateInsert() { - // we are avoiding db.getSession() in here because the constraint violation - // can invalidate the session and there's some chance of deadlock problems - // with multiple sessions so let's just juggle dedicated sessions manually - // for each query and not use the global session from DbTester - - ScaIssueDto issueDto = newScaIssueDto("1"); - try (var dbSession = db.getDbClient().openSession(false)) { - scaIssuesDao.insert(dbSession, issueDto); - dbSession.commit(); - } - - ScaIssueDto issueDtoDifferentUuid = new ScaIssueDto("uuid-different", issueDto.scaIssueType(), issueDto.packageUrl(), - issueDto.vulnerabilityId(), issueDto.spdxLicenseId(), 10L, 11L); - - assertThrows(PersistenceException.class, () -> insertAndCommit(issueDtoDifferentUuid)); - - try (var dbSession = db.getDbClient().openSession(false)) { - List<Map<String, Object>> select = db.select(dbSession, "select * from sca_issues"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsEntry("uuid", issueDto.uuid()); - } - } - - @Test - void selectByUuid_shouldLoadScaIssue() { - ScaIssueDto issueDto = newScaIssueDto("1"); - scaIssuesDao.insert(db.getSession(), issueDto); - - var loadedOptional = scaIssuesDao.selectByUuid(db.getSession(), issueDto.uuid()); - - assertThat(loadedOptional).contains(issueDto); - } - - @Test - void selectByUuids_shouldLoadScaIssues() { - List<ScaIssueDto> issueDtos = List.of(newScaIssueDto("1"), newScaIssueDto("2"), newScaIssueDto("3")); - for (var issueDto : issueDtos) { - scaIssuesDao.insert(db.getSession(), issueDto); - } - - List<String> uuidsToLoad = List.of(issueDtos.get(0).uuid(), issueDtos.get(2).uuid()); - var loaded = scaIssuesDao.selectByUuids(db.getSession(), uuidsToLoad); - - assertThat(loaded).containsExactlyInAnyOrder(issueDtos.get(0), issueDtos.get(2)); - } - - @Test - void selectUuidByValue_shouldLoadScaIssue() { - List<ScaIssueDto> issueDtos = List.of(newScaIssueDto("1"), newScaIssueDto("2"), newScaIssueDto("3")); - for (var issueDto : issueDtos) { - scaIssuesDao.insert(db.getSession(), issueDto); - } - - ScaIssueDto toLoad = issueDtos.get(1); - var loadedOptionalUuid = scaIssuesDao.selectUuidByValue(db.getSession(), toLoad); - - assertThat(loadedOptionalUuid).contains(toLoad.uuid()); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDaoIT.java deleted file mode 100644 index 8a4f5d4bec7..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDaoIT.java +++ /dev/null @@ -1,109 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.util.List; -import java.util.Map; -import org.apache.ibatis.exceptions.PersistenceException; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; - -class ScaIssuesReleasesDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaIssuesReleasesDao scaIssuesReleasesDao = db.getDbClient().scaIssuesReleasesDao(); - - private static ScaIssueReleaseDto newScaIssueReleaseDto(String suffix) { - return new ScaIssueReleaseDto("uuid" + suffix, "sca-issue-uuid" + suffix, "sca-release-uuid" + suffix, ScaSeverity.INFO, 1L, 2L); - } - - @Test - void insert_shouldPersistScaIssuesReleases() { - ScaIssueReleaseDto issueReleaseDto = newScaIssueReleaseDto("1"); - - scaIssuesReleasesDao.insert(db.getSession(), issueReleaseDto); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_issues_releases"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).usingRecursiveComparison().isEqualTo( - Map.ofEntries( - Map.entry("uuid", issueReleaseDto.uuid()), - Map.entry("sca_issue_uuid", issueReleaseDto.scaIssueUuid()), - Map.entry("sca_release_uuid", issueReleaseDto.scaReleaseUuid()), - Map.entry("severity", issueReleaseDto.severity().name()), - Map.entry("severity_sort_key", (long) issueReleaseDto.severitySortKey()), - Map.entry("created_at", issueReleaseDto.createdAt()), - Map.entry("updated_at", issueReleaseDto.updatedAt()))); - } - - // Postgresql apparently doesn't support doing anything else in the session - // after a statement with an error (constraint violation), while other - // databases do. So we use a dedicated session here. - private void insertAndCommit(ScaIssueReleaseDto issueReleaseDto) { - try (var dbSession = db.getDbClient().openSession(false)) { - scaIssuesReleasesDao.insert(dbSession, issueReleaseDto); - dbSession.commit(true); - } - } - - @Test - void insert_shouldFailOnDuplicateInsert() { - ScaIssueReleaseDto issueReleaseDto = newScaIssueReleaseDto("1"); - try (var dbSession = db.getDbClient().openSession(false)) { - scaIssuesReleasesDao.insert(dbSession, issueReleaseDto); - dbSession.commit(); - } - - ScaIssueReleaseDto issueReleaseDtoDifferentUuid = new ScaIssueReleaseDto("uuid-different", - issueReleaseDto.scaIssueUuid(), issueReleaseDto.scaReleaseUuid(), ScaSeverity.INFO, - 10L, 11L); - - assertThrows(PersistenceException.class, () -> insertAndCommit(issueReleaseDtoDifferentUuid)); - - try (var dbSession = db.getDbClient().openSession(false)) { - List<Map<String, Object>> select = db.select(dbSession, "select * from sca_issues_releases"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsEntry("uuid", issueReleaseDto.uuid()); - } - } - - @Test - void deleteByUuid_shouldDelete() { - var dbSession = db.getSession(); - ScaIssueReleaseDto issueReleaseDto = newScaIssueReleaseDto("1"); - scaIssuesReleasesDao.insert(dbSession, issueReleaseDto); - dbSession.commit(); - - assertThat(db.countRowsOfTable(dbSession, "sca_issues_releases")).isOne(); - - scaIssuesReleasesDao.deleteByUuid(dbSession, issueReleaseDto.uuid()); - - assertThat(db.countRowsOfTable(dbSession, "sca_issues_releases")).isZero(); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDetailsDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDetailsDaoIT.java deleted file mode 100644 index 4db2590aed3..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaIssuesReleasesDetailsDaoIT.java +++ /dev/null @@ -1,618 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import com.google.common.collect.Lists; -import java.math.BigDecimal; -import java.util.Collections; -import java.util.Comparator; -import java.util.EnumMap; -import java.util.List; -import java.util.function.Function; -import java.util.stream.Stream; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; -import org.sonar.db.Pagination; -import org.sonar.db.component.ComponentDto; -import org.sonar.db.component.ProjectData; - -import static org.assertj.core.api.Assertions.assertThat; - -class ScaIssuesReleasesDetailsDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaIssuesReleasesDetailsDao scaIssuesReleasesDetailsDao = db.getDbClient().scaIssuesReleasesDetailsDao(); - - private static Comparator<ScaIssueReleaseDetailsDto> identityComparator() { - Function<ScaIssueReleaseDetailsDto, String> typeString = dto -> dto.scaIssueType().name(); - return Comparator.comparing(typeString) - .thenComparing(ScaIssueReleaseDetailsDto::vulnerabilityId) - .thenComparing(ScaIssueReleaseDetailsDto::issuePackageUrl) - .thenComparing(ScaIssueReleaseDetailsDto::spdxLicenseId) - .thenComparing(ScaIssueReleaseDetailsDto::issueReleaseUuid); - } - - private static Comparator<ScaIssueReleaseDetailsDto> severityComparator() { - return Comparator.comparing(dto -> dto.severity().databaseSortKey()); - } - - private static Comparator<ScaIssueReleaseDetailsDto> cvssScoreComparator() { - return Comparator.comparing(ScaIssueReleaseDetailsDto::cvssScore, - // we treat null cvss as a score of 0.0 - Comparator.nullsFirst(Comparator.naturalOrder())); - } - - private static Comparator<ScaIssueReleaseDetailsDto> comparator(ScaIssuesReleasesDetailsQuery.Sort sort) { - return switch (sort) { - case IDENTITY_ASC -> identityComparator(); - case IDENTITY_DESC -> identityComparator().reversed(); - case SEVERITY_ASC -> severityComparator() - .thenComparing(cvssScoreComparator()) - .thenComparing(identityComparator()); - case SEVERITY_DESC -> severityComparator().reversed() - .thenComparing(cvssScoreComparator().reversed()) - .thenComparing(identityComparator()); - case CVSS_SCORE_ASC -> cvssScoreComparator() - .thenComparing(ScaIssueReleaseDetailsDto::severity) - .thenComparing(identityComparator()); - case CVSS_SCORE_DESC -> cvssScoreComparator().reversed() - .thenComparing(Comparator.comparing(ScaIssueReleaseDetailsDto::severity).reversed()) - .thenComparing(identityComparator()); - }; - } - - @Test - void selectByBranchUuid_shouldReturnIssues() { - var projectData = db.components().insertPrivateProject(); - var componentDto = projectData.getMainBranchComponent(); - var issue1 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "1", componentDto.uuid()); - var issue2 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.PROHIBITED_LICENSE, "2", componentDto.uuid()); - - var foundPage = scaIssuesReleasesDetailsDao.selectByBranchUuid(db.getSession(), componentDto.branchUuid(), Pagination.forPage(1).andSize(1)); - - assertThat(foundPage).hasSize(1).isSubsetOf(issue1, issue2); - var foundAllIssues = scaIssuesReleasesDetailsDao.selectByBranchUuid(db.getSession(), componentDto.branchUuid(), Pagination.forPage(1).andSize(10)); - assertThat(foundAllIssues).hasSize(2).containsExactlyElementsOf(Stream.of(issue1, issue2).sorted(comparator(ScaIssuesReleasesDetailsQuery.Sort.SEVERITY_DESC)).toList()); - } - - @Test - void countByBranchUuid_shouldCountIssues() { - var componentDto = db.components().insertPrivateProject().getMainBranchComponent(); - db.getScaIssuesReleasesDetailsDbTester().insertVulnerabilityIssue("1", componentDto.uuid()); - db.getScaIssuesReleasesDetailsDbTester().insertVulnerabilityIssue("2", componentDto.uuid()); - db.getScaIssuesReleasesDetailsDbTester().insertVulnerabilityIssue("3", componentDto.uuid()); - - var count1 = scaIssuesReleasesDetailsDao.countByBranchUuid(db.getSession(), componentDto.branchUuid()); - assertThat(count1).isEqualTo(3); - - assertThat(scaIssuesReleasesDetailsDao.countByBranchUuid(db.getSession(), "bogus-branch-uuid")).isZero(); - } - - @Test - void selectByReleaseUuid_shouldReturnIssues() { - var projectData = db.components().insertPrivateProject(); - var componentDto = projectData.getMainBranchComponent(); - var issue1 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "1", componentDto.uuid()); - var release1 = issue1.releaseDto(); - // make these other issues use the same release and have a variety of CVSS - var issue2 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "2", componentDto.uuid(), - null, vi -> vi.toBuilder().setCvssScore(new BigDecimal("1.1")).build(), - releaseDto -> release1, - issueReleaseDto -> issueReleaseDto.toBuilder().setScaReleaseUuid(release1.uuid()).build()); - var issue3 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "3", componentDto.uuid(), - null, vi -> vi.toBuilder().setCvssScore(new BigDecimal("9.9")).build(), - releaseDto -> release1, - issueReleaseDto -> issueReleaseDto.toBuilder().setScaReleaseUuid(release1.uuid()).build()); - var issue4 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.PROHIBITED_LICENSE, "4", componentDto.uuid(), - null, null, - releaseDto -> release1, - issueReleaseDto -> issueReleaseDto.toBuilder().setScaReleaseUuid(release1.uuid()).build()); - - var foundPage = scaIssuesReleasesDetailsDao.selectByBranchUuid(db.getSession(), componentDto.branchUuid(), Pagination.forPage(1).andSize(1)); - - assertThat(foundPage).hasSize(1).isSubsetOf(issue1, issue2, issue3, issue4); - var foundAllIssues = scaIssuesReleasesDetailsDao.selectByBranchUuid(db.getSession(), componentDto.branchUuid(), Pagination.forPage(1).andSize(10)); - assertThat(foundAllIssues).hasSize(4) - .containsExactlyElementsOf(Stream.of(issue1, issue2, issue3, issue4).sorted(comparator(ScaIssuesReleasesDetailsQuery.Sort.SEVERITY_DESC)).toList()); - } - - @Test - void withNoQueryFilters_shouldReturnAllIssues() { - setupAndExecuteQueryTest(Function.identity(), QueryTestData::expectedIssuesSortedByIdentityAsc, "All issues should be returned"); - } - - @Test - void withNoQueryFilters_shouldCountAllIssues() { - setupAndExecuteQueryCountTest(Function.identity(), 6); - } - - @Test - void withNoQueryFilters_shouldSort() { - QueryTestData testData = createQueryTestData(); - var expectedLists = new EnumMap<ScaIssuesReleasesDetailsQuery.Sort, List<ScaIssueReleaseDetailsDto>>(ScaIssuesReleasesDetailsQuery.Sort.class); - for (var sort : ScaIssuesReleasesDetailsQuery.Sort.values()) { - var expectedIssues = testData.expectedIssuesSorted(sort); - executeQueryTest(testData, queryBuilder -> queryBuilder.setSort(sort), expectedIssues, - "Sort %s should return expected issues".formatted(sort)); - expectedLists.put(sort, expectedIssues); - } - - // The assertions below here are actually about the expectations, but above - // we've just established that the actual matches the expectations. - - // The point of this is to assert that the test data contains a distinct ordering for each - // ordering in ScaIssuesReleasesDetailsQuery.Sort, because if it doesn't we could get - // false negatives in our tests. - assertThat(expectedLists.values().stream().distinct().toList()) - .as("Expected issues should have distinct orderings for each sort") - .containsExactlyInAnyOrderElementsOf(expectedLists.values()); - - // for identity, assert that our ASC and DESC actually invert each other. - // for severity and cvss score, this isn't supposed to be true because the - // secondary sort is IDENTITY_ASC even when we sort by DESC severity; but the - // severity and score values ignoring the other attributes should still be - // reversed. - assertThat(Lists.reverse(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.IDENTITY_ASC))) - .as("IDENTITY sort should be reversed when sorted by DESC") - .containsExactlyElementsOf(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.IDENTITY_DESC)); - assertThat( - Lists.reverse(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.SEVERITY_ASC)).stream() - .map(ScaIssueReleaseDetailsDto::severity) - .toList()) - .as("SEVERITY sort should be reversed when sorted by DESC") - .containsExactlyElementsOf(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.SEVERITY_DESC).stream() - .map(ScaIssueReleaseDetailsDto::severity) - .toList()); - assertThat(Lists.reverse(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.CVSS_SCORE_ASC).stream() - .map(ScaIssueReleaseDetailsDto::cvssScore) - .toList())) - .as("CVSS_SCORE sort should be reversed when sorted by DESC") - .containsExactlyElementsOf(expectedLists.get(ScaIssuesReleasesDetailsQuery.Sort.CVSS_SCORE_DESC).stream() - .map(ScaIssueReleaseDetailsDto::cvssScore) - .toList()); - } - - @Test - void withQueryFilteredByIssueType_shouldReturnExpectedTypes() { - QueryTestData testData = createQueryTestData(); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.VULNERABILITY)), - testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(expected -> expected.scaIssueType() == ScaIssueType.VULNERABILITY) - .toList(), - "Only vulnerability issues should be returned"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.PROHIBITED_LICENSE)), - testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(expected -> expected.scaIssueType() == ScaIssueType.PROHIBITED_LICENSE) - .toList(), - "Only vulnerability issues should be returned"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.values())), - testData.expectedIssuesSortedByIdentityAsc(), - "All issues should be returned"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setTypes(Collections.emptyList()), - Collections.emptyList(), - "No issues should be returned when searching for zero types"); - } - - @Test - void withQueryFilteredByIssueType_shouldCountSelectedIssues() { - QueryTestData testData = createQueryTestData(); - executeQueryCountTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.VULNERABILITY)), - 4); - executeQueryCountTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.PROHIBITED_LICENSE)), - 2); - executeQueryCountTest(testData, - queryBuilder -> queryBuilder.setTypes(List.of(ScaIssueType.values())), - 6); - executeQueryCountTest(testData, - queryBuilder -> queryBuilder.setTypes(Collections.emptyList()), - 0); - } - - @Test - void withQueryFilteredByVulnerabilityId_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedEndsInId1 = testData.expectedIssues().stream() - .filter(issue -> issue.vulnerabilityId() != null && issue.vulnerabilityId().endsWith("Id1")) - .toList(); - assertThat(expectedEndsInId1).hasSize(1); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring("Id1"), - expectedEndsInId1, - "Only the vulnerability ending in Id1 should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring("NotInThere"), - Collections.emptyList(), - "No issues should be returned when searching for the substring 'NotInThere'"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring("Escape% NULL AS!%"), - Collections.emptyList(), - "No issues should be returned when searching for a string that needs escaping"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring(ScaIssueDto.NULL_VALUE), - Collections.emptyList(), - "No vulnerabilities should be returned when searching for ScaIssueDto.NULL_VALUE"); - - var allVulnerabilityIssues = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> issue.scaIssueType() == ScaIssueType.VULNERABILITY) - .toList(); - assertThat(allVulnerabilityIssues).hasSize(4); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring("Vulnerability"), - allVulnerabilityIssues, - "All vulnerabilities should be returned when searching for the substring 'Vulnerability'"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setVulnerabilityIdSubstring(""), - allVulnerabilityIssues, - "All vulnerabilities should be returned when searching for empty vulnerabilityId"); - } - - @Test - void withQueryFilteredByPackageName_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedEndsInName1 = testData.expectedIssues().subList(0, 1); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring("Name1"), - expectedEndsInName1, - "Only the packages containing Name1 should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring("NotInThere"), - Collections.emptyList(), - "No issues should be returned when searching for the substring 'NotInThere'"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring("Escape% NULL AS!%"), - Collections.emptyList(), - "No issues should be returned when searching for a string that needs escaping"); - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring(ScaIssueDto.NULL_VALUE), - Collections.emptyList(), - "No vulnerabilities should be returned when searching for ScaIssueDto.NULL_VALUE"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring("Package"), - testData.expectedIssuesSortedByIdentityAsc(), - "All issues should be returned when searching for the substring 'Package'"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageNameSubstring(""), - testData.expectedIssuesSortedByIdentityAsc(), - "All issues should be returned when searching for empty package name"); - } - - @Test - void withQueryFilteredByNewInPullRequest_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - - var expectedNew = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> issue.newInPullRequest()) - .toList(); - var expectedNotNew = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> !issue.newInPullRequest()) - .toList(); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setNewInPullRequest(true), - expectedNew, - "Only the releases marked newInPullRequest should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setNewInPullRequest(false), - expectedNotNew, - "Only the releases marked not newInPullRequest should be returned"); - } - - @Test - void withQueryFilteredBySeverity_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedSeverityInfo = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> issue.severity() == ScaSeverity.INFO) - .toList(); - var expectedSeverityBlocker = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> issue.severity() == ScaSeverity.BLOCKER) - .toList(); - assertThat(expectedSeverityInfo).hasSize(5); - assertThat(expectedSeverityBlocker).hasSize(1); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setSeverities(List.of(ScaSeverity.INFO)), - expectedSeverityInfo, - "Only the issues of severity INFO should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setSeverities(List.of(ScaSeverity.BLOCKER)), - expectedSeverityBlocker, - "Only the issues of severity BLOCKER should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setSeverities(List.of(ScaSeverity.LOW, ScaSeverity.HIGH)), - Collections.emptyList(), - "Should not match any severities of LOW or HIGH"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setSeverities(List.of(ScaSeverity.BLOCKER, ScaSeverity.INFO, ScaSeverity.LOW)), - testData.expectedIssuesSortedByIdentityAsc(), - "All issues should be returned when searching for a list that contains them all"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setSeverities(Collections.emptyList()), - Collections.emptyList(), - "No issues should be returned when searching for zero severities"); - } - - @Test - void withQueryFilteredByPackageManager_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedPackageManagerNpm = testData.expectedIssuesWithPackageManager(PackageManager.NPM).stream() - .sorted(identityComparator()).toList(); - var expectedPackageManagerMaven = testData.expectedIssuesWithPackageManager(PackageManager.MAVEN).stream() - .sorted(identityComparator()).toList(); - - assertThat(expectedPackageManagerNpm).hasSize(2); - assertThat(expectedPackageManagerMaven).hasSize(4); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageManagers(List.of(PackageManager.NPM)), - expectedPackageManagerNpm, - "Only the npm issues should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageManagers(List.of(PackageManager.MAVEN)), - expectedPackageManagerMaven, - "Only the Maven issues should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageManagers(List.of(PackageManager.NPM, PackageManager.MAVEN)), - testData.expectedIssuesSortedByIdentityAsc(), - "All issues should be returned when searching for two package managers"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setPackageManagers(Collections.emptyList()), - Collections.emptyList(), - "No issues should be returned when searching for zero package managers"); - } - - @Test - void withQueryFilteredByDirect_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedDirect = testData.directIssues(); - var expectedTransitive = testData.transitiveIssues(); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setDirect(true), - expectedDirect, - "Only direct issues should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setDirect(false), - expectedTransitive, - "Only the transitive issues should be returned"); - } - - @Test - void withQueryFilteredByProductionScope_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedProduction = testData.productionIssues(); - var expectedNotProduction = testData.notProductionIssues(); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setProductionScope(true), - expectedProduction, - "Only production issues should be returned"); - - executeQueryTest(testData, - queryBuilder -> queryBuilder.setProductionScope(false), - expectedNotProduction, - "Only the non-production issues should be returned"); - } - - @Test - void withQueryMultipleFiltersNonDefaultSort_shouldReturnExpectedItems() { - QueryTestData testData = createQueryTestData(); - var expectedPackageManagerMaven = testData.expectedIssuesWithPackageManager(PackageManager.MAVEN); - var expectedTypeVulnerability = testData.expectedIssuesSortedByIdentityAsc().stream() - .filter(issue -> issue.scaIssueType() == ScaIssueType.VULNERABILITY) - .toList(); - var sortedByCvssDesc = testData.expectedIssuesSortedByCvssDesc(); - var expectedResults = sortedByCvssDesc.stream() - .filter(expectedPackageManagerMaven::contains) - .filter(expectedTypeVulnerability::contains) - .toList(); - assertThat(expectedResults).hasSize(3); - - executeQueryTest(testData, - queryBuilder -> queryBuilder - .setSort(ScaIssuesReleasesDetailsQuery.Sort.CVSS_SCORE_DESC) - .setPackageManagers(List.of(PackageManager.MAVEN)) - .setTypes(List.of(ScaIssueType.VULNERABILITY)), - expectedResults, - "Maven vulnerabilities returned in cvss score desc order"); - } - - private void setupAndExecuteQueryTest(Function<ScaIssuesReleasesDetailsQuery.Builder, ScaIssuesReleasesDetailsQuery.Builder> builderFunction, - Function<QueryTestData, List<ScaIssueReleaseDetailsDto>> expectedIssuesFunction, String assertAs) { - QueryTestData testData = createQueryTestData(); - executeQueryTest(testData, builderFunction, expectedIssuesFunction.apply(testData), assertAs); - } - - private void executeQueryTest(QueryTestData testData, - Function<ScaIssuesReleasesDetailsQuery.Builder, ScaIssuesReleasesDetailsQuery.Builder> builderFunction, - List<ScaIssueReleaseDetailsDto> expectedIssues, - String assertAs) { - var query = builderFunction.apply( - new ScaIssuesReleasesDetailsQuery.Builder() - .setBranchUuid(testData.branchUuid()) - .setSort(ScaIssuesReleasesDetailsQuery.Sort.IDENTITY_ASC)) - .build(); - var foundPage = scaIssuesReleasesDetailsDao.selectByQuery(db.getSession(), query, Pagination.forPage(1).andSize(10)); - - assertThat(foundPage).as(assertAs).containsExactlyElementsOf(expectedIssues); - } - - private void setupAndExecuteQueryCountTest(Function<ScaIssuesReleasesDetailsQuery.Builder, ScaIssuesReleasesDetailsQuery.Builder> builderFunction, - int expectedCount) { - QueryTestData testData = createQueryTestData(); - executeQueryCountTest(testData, builderFunction, expectedCount); - } - - private void executeQueryCountTest(QueryTestData testData, - Function<ScaIssuesReleasesDetailsQuery.Builder, ScaIssuesReleasesDetailsQuery.Builder> builderFunction, - int expectedCount) { - var query = builderFunction.apply( - new ScaIssuesReleasesDetailsQuery.Builder() - .setBranchUuid(testData.branchUuid()) - .setSort(ScaIssuesReleasesDetailsQuery.Sort.IDENTITY_ASC)) - .build(); - var count = scaIssuesReleasesDetailsDao.countByQuery(db.getSession(), query); - - assertThat(count).isEqualTo(expectedCount); - } - - private QueryTestData createQueryTestData() { - var projectData = db.components().insertPrivateProject(); - var componentDto = projectData.getMainBranchComponent(); - // the first two are set to NPM, the others default to MAVEN - var issue1 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "1", componentDto.uuid(), - scaIssueDto -> scaIssueDto, - scaVulnerabilityIssueDto -> scaVulnerabilityIssueDto, - scaReleaseDto -> scaReleaseDto.toBuilder().setPackageManager(PackageManager.NPM).build(), - scaIssueReleaseDto -> scaIssueReleaseDto); - var issue2 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.PROHIBITED_LICENSE, "2", componentDto.uuid(), - scaIssueDto -> scaIssueDto, - scaVulnerabilityIssueDto -> scaVulnerabilityIssueDto, - scaReleaseDto -> scaReleaseDto.toBuilder().setPackageManager(PackageManager.NPM).build(), - scaIssueReleaseDto -> scaIssueReleaseDto); - var issue3 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "3", componentDto.uuid()); - var issue4 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.PROHIBITED_LICENSE, "4", componentDto.uuid()); - // low cvss but high severity - var issue5 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "5", componentDto.uuid(), - scaIssueDto -> scaIssueDto, - scaVulnerabilityIssueDto -> scaVulnerabilityIssueDto.toBuilder() - .setCvssScore(new BigDecimal("2.1")) - .setBaseSeverity(ScaSeverity.BLOCKER) - .build(), - scaReleaseDto -> scaReleaseDto.toBuilder().setNewInPullRequest(true).build(), - scaIssueReleaseDto -> scaIssueReleaseDto.toBuilder().setSeverity(ScaSeverity.BLOCKER).build()); - // high cvss but low severity - var issue6 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "6", componentDto.uuid(), - scaIssueDto -> scaIssueDto, - scaVulnerabilityIssueDto -> scaVulnerabilityIssueDto.toBuilder() - .setCvssScore(new BigDecimal("9.1")) - .setBaseSeverity(ScaSeverity.INFO) - .build(), - scaReleaseDto -> scaReleaseDto.toBuilder().setNewInPullRequest(true).build(), - scaIssueReleaseDto -> scaIssueReleaseDto.toBuilder().setSeverity(ScaSeverity.INFO).build()); - - // issue 1 weirdly has no dependency, issues 2-3 are direct, issues 4-6 are transitive - // issues 2 and 4 are production, 3,5,6 are not production - db.getScaDependenciesDbTester().insertScaDependency(issue2.releaseUuid(), "2", - builder -> builder.setDirect(true).setProductionScope(true)); - var dep3 = db.getScaDependenciesDbTester().insertScaDependency(issue3.releaseUuid(), "3", - builder -> builder.setDirect(true).setProductionScope(false)); - var dep4 = db.getScaDependenciesDbTester().insertScaDependency(issue4.releaseUuid(), "4", - builder -> builder.setDirect(false).setProductionScope(true)); - var dep5 = db.getScaDependenciesDbTester().insertScaDependency(issue5.releaseUuid(), "5", - builder -> builder.setDirect(false).setProductionScope(false)); - db.getScaDependenciesDbTester().insertScaDependency(issue6.releaseUuid(), "6", - builder -> builder.setDirect(false).setProductionScope(false)); - - // make issue3 and issue4 BOTH direct and transitive, - // issue4 and issue5 are BOTH production and not - db.getScaDependenciesDbTester().insertScaDependency(issue3.releaseUuid(), "7", - builder -> builder.setDirect(!dep3.direct()).setProductionScope(dep3.productionScope())); - db.getScaDependenciesDbTester().insertScaDependency(issue4.releaseUuid(), "8", - builder -> builder.setDirect(!dep4.direct()).setProductionScope(!dep4.productionScope())); - db.getScaDependenciesDbTester().insertScaDependency(issue5.releaseUuid(), "9", - builder -> builder.setDirect(dep5.direct()).setProductionScope(!dep5.productionScope())); - - var directIssues = List.of(issue2, issue3, issue4).stream().sorted(identityComparator()).toList(); - var transitiveIssues = List.of(issue3, issue4, issue5, issue6).stream().sorted(identityComparator()).toList(); - var productionIssues = List.of(issue2, issue4, issue5).stream().sorted(identityComparator()).toList(); - var notProductionIssues = List.of(issue3, issue4, issue5, issue6).stream().sorted(identityComparator()).toList(); - - return new QueryTestData(projectData, componentDto, - List.of(issue1, issue2, issue3, issue4, issue5, issue6), - directIssues, transitiveIssues, productionIssues, notProductionIssues); - } - - @Test - void selectByScaIssueReleaseUuid_shouldReturnAnIssue() { - var projectData = db.components().insertPrivateProject(); - var componentDto = projectData.getMainBranchComponent(); - var issue1 = db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.VULNERABILITY, "1", componentDto.uuid()); - - // insert another issue to assert that it's not selected - db.getScaIssuesReleasesDetailsDbTester().insertIssue(ScaIssueType.PROHIBITED_LICENSE, "2", componentDto.uuid()); - - var foundIssue = scaIssuesReleasesDetailsDao.selectByScaIssueReleaseUuid(db.getSession(), issue1.issueReleaseUuid()); - assertThat(foundIssue).isEqualTo(issue1); - - var notFoundIssue = scaIssuesReleasesDetailsDao.selectByScaIssueReleaseUuid(db.getSession(), "00000"); - assertThat(notFoundIssue).isNull(); - } - - private record QueryTestData(ProjectData projectData, - ComponentDto componentDto, - List<ScaIssueReleaseDetailsDto> expectedIssues, - List<ScaIssueReleaseDetailsDto> directIssues, - List<ScaIssueReleaseDetailsDto> transitiveIssues, - List<ScaIssueReleaseDetailsDto> productionIssues, - List<ScaIssueReleaseDetailsDto> notProductionIssues) { - - public String branchUuid() { - return componentDto.branchUuid(); - } - - public List<ScaIssueReleaseDetailsDto> expectedIssuesSorted(ScaIssuesReleasesDetailsQuery.Sort sort) { - return expectedIssues.stream().sorted(comparator(sort)).toList(); - } - - public List<ScaIssueReleaseDetailsDto> expectedIssuesSortedByIdentityAsc() { - return expectedIssuesSorted(ScaIssuesReleasesDetailsQuery.Sort.IDENTITY_ASC); - } - - public List<ScaIssueReleaseDetailsDto> expectedIssuesSortedByCvssDesc() { - return expectedIssuesSorted(ScaIssuesReleasesDetailsQuery.Sort.CVSS_SCORE_DESC); - } - - public List<ScaIssueReleaseDetailsDto> expectedIssuesWithPackageManager(PackageManager packageManager) { - // we just have hardcoded knowledge of how we set them up, because ScaIssueReleaseDetailsDto doesn't - // contain the ScaReleaseDto to look at this - return switch (packageManager) { - case NPM -> expectedIssues.subList(0, 2); - case MAVEN -> expectedIssues.subList(2, expectedIssues.size()); - default -> Collections.emptyList(); - }; - } - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDaoIT.java deleted file mode 100644 index f59f2fbf39c..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDaoIT.java +++ /dev/null @@ -1,315 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; -import org.assertj.core.groups.Tuple; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.slf4j.LoggerFactory; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; -import org.sonar.db.Pagination; -import org.sonar.db.component.ComponentDto; -import org.sonar.db.component.ProjectData; - -import static org.assertj.core.api.Assertions.assertThat; - -class ScaReleasesDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaReleasesDao scaReleasesDao = db.getDbClient().scaReleasesDao(); - - @Test - void insert_shouldPersistScaReleases() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_releases"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", scaReleaseDto.uuid()), - Map.entry("component_uuid", scaReleaseDto.componentUuid()), - Map.entry("package_url", scaReleaseDto.packageUrl()), - Map.entry("package_manager", scaReleaseDto.packageManager().name()), - Map.entry("package_name", scaReleaseDto.packageName()), - Map.entry("version", scaReleaseDto.version()), - Map.entry("license_expression", scaReleaseDto.licenseExpression()), - Map.entry("declared_license_expression", scaReleaseDto.declaredLicenseExpression()), - Map.entry("known", scaReleaseDto.known()), - Map.entry("new_in_pull_request", scaReleaseDto.newInPullRequest()), - Map.entry("created_at", scaReleaseDto.createdAt()), - Map.entry("updated_at", scaReleaseDto.updatedAt()))); - } - - @Test - void deleteByUuid_shouldDeleteScaReleases() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_releases"); - assertThat(select).isNotEmpty(); - - scaReleasesDao.deleteByUuid(db.getSession(), scaReleaseDto.uuid()); - - select = db.select(db.getSession(), "select * from sca_releases"); - assertThat(select).isEmpty(); - } - - @Test - void selectByUuid_shouldLoadScaRelease() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - - var loadedOptional = scaReleasesDao.selectByUuid(db.getSession(), scaReleaseDto.uuid()); - - assertThat(loadedOptional).contains(scaReleaseDto); - } - - @Test - void selectByUuid_shouldLoadScaReleases() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2"); - ScaReleaseDto scaReleaseDto3 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "3"); - - // we don't ask for the second one, so this tests we only get what we asked for. - var loaded = scaReleasesDao.selectByUuids(db.getSession(), Set.of(scaReleaseDto1.uuid(), scaReleaseDto3.uuid())); - - assertThat(loaded).containsExactlyInAnyOrder(scaReleaseDto1, scaReleaseDto3); - } - - @Test - void selectByUuid_shouldLoadEmptyScaReleases() { - ComponentDto componentDto = prepareComponentDto(); - db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2"); - db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "3"); - - var loaded = scaReleasesDao.selectByUuids(db.getSession(), Collections.emptyList()); - - assertThat(loaded).isEmpty(); - } - - @Test - void selectByQuery_shouldReturnScaReleases_whenQueryByBranchUuid() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - System.out.println("componentDto = " + componentDto); - - ScaReleasesQuery scaReleasesQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, null, null, null); - List<ScaReleaseDto> results = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesQuery, Pagination.all()); - - assertThat(results).hasSize(1); - assertThat(results.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto); - } - - @Test - void selectByQuery_shouldReturnPaginatedScaReleases() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - ScaReleaseDto scaReleaseDto2 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2"); - ScaReleaseDto scaReleaseDto3 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "3"); - ScaReleaseDto scaReleaseDto4 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "4"); - - ScaReleasesQuery scaReleasesQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, null, null, null); - List<ScaReleaseDto> page1Results = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesQuery, Pagination.forPage(1).andSize(2)); - List<ScaReleaseDto> page2Results = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesQuery, Pagination.forPage(2).andSize(2)); - - // we order by created_at so it would seem we can assert the order here... except that created_at has finite resolution, so it can be nondeterministic. - var allResults = new ArrayList<>(page1Results); - allResults.addAll(page2Results); - assertThat(allResults).containsExactlyInAnyOrder(scaReleaseDto1, scaReleaseDto2, scaReleaseDto3, scaReleaseDto4); - assertThat(List.of(page1Results.size(), page2Results.size())).containsExactly(2, 2); - } - - @Test - void selectByQuery_shouldPartiallyMatchPackageName_whenQueriedByText() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1", PackageManager.MAVEN, "foo.bar"); - db.getScaDependenciesDbTester().insertScaDependency(scaReleaseDto1, "1", true); - db.getScaDependenciesDbTester().insertScaDependency(scaReleaseDto1, "2", false); - var log = LoggerFactory.getLogger(""); - List<Map<String, Object>> temp = db.select(db.getSession(), "select * from sca_releases"); - log.warn("sca_releases: {}", temp.stream().count()); - for (Map<String, Object> map : temp) { - log.warn(map.toString()); - } - temp = db.select(db.getSession(), "select * from sca_dependencies"); - log.warn("sca_dependencies: {}", temp.stream().count()); - for (Map<String, Object> map : temp) { - log.warn(map.toString()); - } - - @SuppressWarnings("unused") - ScaReleaseDto scaReleaseDto2 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2", PackageManager.MAVEN, "bar.mee"); - ScaReleaseDto scaReleaseDto3 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "3", PackageManager.MAVEN, "foo.bar.me"); - @SuppressWarnings("unused") - ScaReleaseDto scaReleaseDto4 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "4", PackageManager.MAVEN, "some.foo.bar"); - - ScaReleasesQuery scaReleasesQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, null, null, "foo"); - List<ScaReleaseDto> results = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesQuery, Pagination.all()); - - assertThat(results).hasSize(3); - assertThat(results.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto1); - assertThat(results.get(1)).usingRecursiveComparison().isEqualTo(scaReleaseDto3); - - ScaReleasesQuery scaReleasesCaseInsensitiveQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, null, null, "Foo.Bar"); - List<ScaReleaseDto> resultsCaseInsensitive = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesCaseInsensitiveQuery, Pagination.all()); - - assertThat(resultsCaseInsensitive).hasSize(3); - assertThat(resultsCaseInsensitive.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto1); - assertThat(resultsCaseInsensitive.get(1)).usingRecursiveComparison().isEqualTo(scaReleaseDto3); - } - - @Test - void selectByQuery_shouldReturnScaReleases_whenQueryByDirect() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto.uuid(), "1", 2, true, PackageManager.MAVEN, "foo.bar"); - ScaReleaseDto scaReleaseDto2 = db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto.uuid(), "2", 3, false, PackageManager.MAVEN, "foo.bar"); - - ScaReleasesQuery scaReleasesDirectQuery = new ScaReleasesQuery(componentDto.branchUuid(), true, null, null, null, null); - List<ScaReleaseDto> resultsDirect = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesDirectQuery, Pagination.all()); - - assertThat(resultsDirect).hasSize(1); - assertThat(resultsDirect.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto1); - - ScaReleasesQuery scaReleasesNoDirectQuery = new ScaReleasesQuery(componentDto.branchUuid(), false, null, null, null, null); - List<ScaReleaseDto> resultsNoDirect = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesNoDirectQuery, Pagination.all()); - - assertThat(resultsNoDirect).hasSize(1); - assertThat(resultsNoDirect.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto2); - } - - @Test - void selectByQuery_shouldReturnScaReleases_whenQueryByProductionScope() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1"); - ScaReleaseDto scaReleaseDto2 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2"); - db.getScaDependenciesDbTester().insertScaDependency(scaReleaseDto1, "1", builder -> builder.setProductionScope(true)); - db.getScaDependenciesDbTester().insertScaDependency(scaReleaseDto2, "2", builder -> builder.setProductionScope(false)); - - ScaReleasesQuery scaReleasesProductionScopeQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, true, null, null, null); - List<ScaReleaseDto> resultsProductionScope = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesProductionScopeQuery, Pagination.all()); - - assertThat(resultsProductionScope).hasSize(1); - assertThat(resultsProductionScope.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto1); - - ScaReleasesQuery scaReleasesNoProductionScopeQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, false, null, null, null); - List<ScaReleaseDto> resultsNoProductionScope = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesNoProductionScopeQuery, Pagination.all()); - - assertThat(resultsNoProductionScope).hasSize(1); - assertThat(resultsNoProductionScope.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto2); - } - - @Test - void selectByQuery_shouldReturnScaReleases_whenQueryByPackageManager() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto1 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1", PackageManager.MAVEN, "foo.bar"); - ScaReleaseDto scaReleaseDto2 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "2", PackageManager.NPM, "foo.bar"); - ScaReleaseDto scaReleaseDto3 = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "3", PackageManager.CARGO, "foo.bar"); - - ScaReleasesQuery scaReleasesMavenQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, List.of(PackageManager.MAVEN.name()), null, null); - List<ScaReleaseDto> resultsMaven = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesMavenQuery, Pagination.all()); - - assertThat(resultsMaven).hasSize(1); - assertThat(resultsMaven.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto1); - - ScaReleasesQuery scaReleasesNpmAndCargoQuery = new ScaReleasesQuery(componentDto.branchUuid(), null, null, - List.of(PackageManager.NPM.name(), PackageManager.CARGO.name()), null, null); - List<ScaReleaseDto> resultsNpm = scaReleasesDao.selectByQuery(db.getSession(), scaReleasesNpmAndCargoQuery, Pagination.all()); - - assertThat(resultsNpm).hasSize(2); - assertThat(resultsNpm.get(0)).usingRecursiveComparison().isEqualTo(scaReleaseDto2); - assertThat(resultsNpm.get(1)).usingRecursiveComparison().isEqualTo(scaReleaseDto3); - } - - @Test - void update_shouldUpdateScaRelease() { - ComponentDto componentDto = prepareComponentDto(); - ScaReleaseDto scaReleaseDto = db.getScaReleasesDbTester().insertScaRelease(componentDto.uuid(), "1", PackageManager.MAVEN, "foo.bar"); - ScaReleaseDto updatedScaRelease = scaReleaseDto.toBuilder().setUpdatedAt(scaReleaseDto.updatedAt() + 1).setVersion("newVersion").build(); - - scaReleasesDao.update(db.getSession(), updatedScaRelease); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_releases"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", updatedScaRelease.uuid()), - Map.entry("component_uuid", updatedScaRelease.componentUuid()), - Map.entry("package_url", updatedScaRelease.packageUrl()), - Map.entry("package_manager", updatedScaRelease.packageManager().name()), - Map.entry("package_name", updatedScaRelease.packageName()), - Map.entry("version", updatedScaRelease.version()), - Map.entry("license_expression", updatedScaRelease.licenseExpression()), - Map.entry("declared_license_expression", updatedScaRelease.declaredLicenseExpression()), - Map.entry("known", updatedScaRelease.known()), - Map.entry("new_in_pull_request", updatedScaRelease.newInPullRequest()), - Map.entry("created_at", updatedScaRelease.createdAt()), - Map.entry("updated_at", updatedScaRelease.updatedAt()))); - } - - @Test - void countByQuery_shouldReturnTheTotalOfReleases() { - ComponentDto componentDto1 = prepareComponentDto(); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "1", 1, true, PackageManager.MAVEN, "foo.bar"); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "2", 2, true, PackageManager.MAVEN, "foo.bar.mee"); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "3", 3, true, PackageManager.MAVEN, "bar.fo"); - - ScaReleasesQuery scaReleasesQuery = new ScaReleasesQuery(componentDto1.branchUuid(), null, null, null, null, "foo"); - - assertThat(scaReleasesDao.countByQuery(db.getSession(), scaReleasesQuery)).isEqualTo(2); - assertThat(scaReleasesDao.countByQuery(db.getSession(), new ScaReleasesQuery(componentDto1.branchUuid(), null, null, null, null, null))).isEqualTo(3); - assertThat(scaReleasesDao.countByQuery(db.getSession(), new ScaReleasesQuery("another_branch_uuid", null, null, null, null, null))).isZero(); - } - - private ComponentDto prepareComponentDto() { - ProjectData projectData = db.components().insertPublicProject(); - return projectData.getMainBranchComponent(); - } - - @Test - void countByPlatformQuery_shouldReturnPlatforms() { - ComponentDto componentDto1 = prepareComponentDto(); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "1", 1, true, PackageManager.MAVEN, "foo.bar"); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "2", 2, true, PackageManager.NPM, "foo.bar.mee"); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "3", 3, true, PackageManager.MAVEN, "bar.foo"); - db.getScaReleasesDbTester().insertScaReleaseWithDependency(componentDto1.uuid(), "4", 4, true, PackageManager.PYPI, "bar.foo"); - - ScaReleasesQuery scaReleasesQuery = new ScaReleasesQuery(componentDto1.branchUuid(), null, null, null, null, null); - - List<ScaReleaseByPackageManagerCountDto> releaseCounts = scaReleasesDao.countReleasesByPackageManager(db.getSession(), scaReleasesQuery); - assertThat(releaseCounts).hasSize(3); - assertThat(releaseCounts).extracting("packageManager", "releaseCount") - .containsExactlyInAnyOrder(Tuple.tuple(PackageManager.MAVEN.name(), 2), - Tuple.tuple(PackageManager.NPM.name(), 1), - Tuple.tuple(PackageManager.PYPI.name(), 1)); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDependenciesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDependenciesDaoIT.java deleted file mode 100644 index e8384f05a0c..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaReleasesDependenciesDaoIT.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.util.List; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; -import org.sonar.db.component.ComponentDto; - -import static org.assertj.core.api.Assertions.assertThat; - -class ScaReleasesDependenciesDaoIT { - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaReleasesDependenciesDao scaReleasesDependenciesDao = db.getDbClient().scaReleasesDependenciesDao(); - - @Test - void test_whenEmptyDatabaseAndQuery_selectByReleaseUuids() { - assertThat(scaReleasesDependenciesDao.selectByReleaseUuids(db.getSession(), List.of())).isEmpty(); - } - - @Test - void test_whenSomeDependencies_selectByReleaseUuids() { - ComponentDto componentDto = db.components().insertPublicProject().getMainBranchComponent(); - - ScaDependencyDto scaDependencyDto1a = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "1a", true, PackageManager.MAVEN, "foo.bar1"); - // same release, different dependency - ScaDependencyDto scaDependencyDto1b = db.getScaDependenciesDbTester().insertScaDependency(scaDependencyDto1a.scaReleaseUuid(), "1b", false); - ScaDependencyDto scaDependencyDto2 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "2", true, PackageManager.MAVEN, "foo.bar2"); - ScaDependencyDto scaDependencyDto3 = db.getScaDependenciesDbTester().insertScaDependencyWithRelease(componentDto.uuid(), "3", true, PackageManager.MAVEN, "foo.bar3"); - - List<ScaReleaseDependenciesDto> results = scaReleasesDependenciesDao.selectByReleaseUuids(db.getSession(), - List.of(scaDependencyDto1a.scaReleaseUuid(), scaDependencyDto2.scaReleaseUuid())); - - assertThat(results.stream().map(ScaReleaseDependenciesDto::dependencies).flatMap(List::stream).toList()) - .containsExactlyInAnyOrder(scaDependencyDto1a, scaDependencyDto1b, scaDependencyDto2) - .doesNotContain(scaDependencyDto3); - var twoDeps = results.stream().filter(rd -> rd.releaseUuid().equals(scaDependencyDto1a.scaReleaseUuid())) - .findFirst().map(ScaReleaseDependenciesDto::dependencies).orElseThrow(); - assertThat(twoDeps).containsExactlyInAnyOrder(scaDependencyDto1a, scaDependencyDto1b); - - var resultsWithEmptyQuery = scaReleasesDependenciesDao.selectByReleaseUuids(db.getSession(), List.of()); - assertThat(resultsWithEmptyQuery).isEmpty(); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaVulnerabilityIssuesDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaVulnerabilityIssuesDaoIT.java deleted file mode 100644 index dbfbaf3d6d2..00000000000 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/sca/ScaVulnerabilityIssuesDaoIT.java +++ /dev/null @@ -1,141 +0,0 @@ -/* - * SonarQube - * Copyright (C) 2009-2025 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.db.sca; - -import java.math.BigDecimal; -import java.math.RoundingMode; -import java.util.List; -import java.util.Map; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.RegisterExtension; -import org.sonar.api.utils.System2; -import org.sonar.db.DbTester; - -import static org.assertj.core.api.Assertions.assertThat; - -class ScaVulnerabilityIssuesDaoIT { - - @RegisterExtension - private final DbTester db = DbTester.create(System2.INSTANCE); - - private final ScaVulnerabilityIssuesDao scaVulnerabilityIssuesDao = db.getDbClient().scaVulnerabilityIssuesDao(); - - private static final ScaVulnerabilityIssueDto newScaVulnerabilityIssueDto(String suffix) { - return new ScaVulnerabilityIssueDto("uuid" + suffix, ScaSeverity.INFO, List.of("cwe-" + suffix), new BigDecimal("7.1"), 1L, 2L); - } - - @Test - void insert_shouldPersistScaVulnerabilityIssues() { - ScaVulnerabilityIssueDto issueDto = newScaVulnerabilityIssueDto("1"); - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - - List<Map<String, Object>> select = db.select(db.getSession(), "select * from sca_vulnerability_issues"); - assertThat(select).hasSize(1); - Map<String, Object> stringObjectMap = select.get(0); - // we can't compare doubles, so it's hackin' time - var possibleDouble = stringObjectMap.get("cvss_score"); - if (possibleDouble instanceof Double d) { - stringObjectMap.put("cvss_score", BigDecimal.valueOf(d)); - } - assertThat(stringObjectMap).containsExactlyInAnyOrderEntriesOf( - Map.ofEntries( - Map.entry("uuid", issueDto.uuid()), - Map.entry("base_severity", issueDto.baseSeverity().name()), - Map.entry("cwe_ids", "[" + String.join(", ", issueDto.cweIds().stream().map(s -> "\"" + s + "\"").toList()) + "]"), - Map.entry("cvss_score", issueDto.cvssScore()), - Map.entry("created_at", issueDto.createdAt()), - Map.entry("updated_at", issueDto.updatedAt()))); - } - - @Test - void insert_canSaveNullCvssScore() { - ScaVulnerabilityIssueDto issueDtoNotNull = newScaVulnerabilityIssueDto("1"); - ScaVulnerabilityIssueDto issueDto = new ScaVulnerabilityIssueDto(issueDtoNotNull.uuid(), ScaSeverity.INFO, issueDtoNotNull.cweIds(), - null, issueDtoNotNull.createdAt(), issueDtoNotNull.updatedAt()); - - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - - var loadedOptional = scaVulnerabilityIssuesDao.selectByUuid(db.getSession(), issueDto.uuid()); - - assertThat(loadedOptional).contains(issueDto); - assertThat(loadedOptional.get().cvssScore()).isNull(); - } - - @Test - void insert_canSaveTenCvssScore() { - ScaVulnerabilityIssueDto issueDtoBase = newScaVulnerabilityIssueDto("1"); - ScaVulnerabilityIssueDto issueDto = new ScaVulnerabilityIssueDto(issueDtoBase.uuid(), ScaSeverity.INFO, - issueDtoBase.cweIds(), new BigDecimal("10.0"), issueDtoBase.createdAt(), issueDtoBase.updatedAt()); - assertThat(issueDto.cvssScore().scale()).isEqualTo(1); - - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - - // the different db backends are not consistent about actually keeping the scale - // so we have to fix it to be what we expect - var loadedOptionalScore = scaVulnerabilityIssuesDao.selectByUuid(db.getSession(), issueDto.uuid()) - .map(ScaVulnerabilityIssueDto::cvssScore) - .map(score -> score.setScale(1, RoundingMode.HALF_UP)); - - assertThat(loadedOptionalScore).contains(issueDto.cvssScore()); - } - - @Test - void selectByUuid_shouldLoadScaVulnerabilityIssue() { - ScaVulnerabilityIssueDto issueDto = newScaVulnerabilityIssueDto("1"); - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - - var loadedOptional = scaVulnerabilityIssuesDao.selectByUuid(db.getSession(), issueDto.uuid()); - - assertThat(loadedOptional).contains(issueDto); - } - - @Test - void selectByUuids_shouldLoadScaVulnerabilityIssues() { - List<ScaVulnerabilityIssueDto> issueDtos = List.of(newScaVulnerabilityIssueDto("1"), - newScaVulnerabilityIssueDto("2"), newScaVulnerabilityIssueDto("3")); - for (var issueDto : issueDtos) { - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - } - - List<String> uuidsToLoad = List.of(issueDtos.get(0).uuid(), issueDtos.get(2).uuid()); - var loaded = scaVulnerabilityIssuesDao.selectByUuids(db.getSession(), uuidsToLoad); - - assertThat(loaded).containsExactlyInAnyOrder(issueDtos.get(0), issueDtos.get(2)); - } - - @Test - void update_shouldModifyScaVulnerabilityIssue() { - ScaVulnerabilityIssueDto issueDto = newScaVulnerabilityIssueDto("1"); - scaVulnerabilityIssuesDao.insert(db.getSession(), issueDto); - ScaVulnerabilityIssueDto issueDtoUpdated = new ScaVulnerabilityIssueDto(issueDto.uuid(), - ScaSeverity.BLOCKER, - issueDto.cweIds().stream().map(s -> s + "-updated").toList(), - issueDto.cvssScore().add(new BigDecimal("1.3")), - issueDto.createdAt(), 5L); - - assertThat(issueDtoUpdated.baseSeverity()).isNotEqualTo(issueDto.baseSeverity()); - - scaVulnerabilityIssuesDao.update(db.getSession(), issueDtoUpdated); - - var loadedOptional = scaVulnerabilityIssuesDao.selectByUuid(db.getSession(), issueDto.uuid()); - - assertThat(loadedOptional).contains(issueDtoUpdated); - } -} diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/user/RoleDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/user/RoleDaoIT.java index 51740d120f0..a2ad19232a7 100644 --- a/server/sonar-db-dao/src/it/java/org/sonar/db/user/RoleDaoIT.java +++ b/server/sonar-db-dao/src/it/java/org/sonar/db/user/RoleDaoIT.java @@ -27,7 +27,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.RegisterExtension; import org.sonar.db.component.ComponentQualifiers; import org.sonar.api.utils.System2; -import org.sonar.api.web.UserRole; +import org.sonar.db.permission.ProjectPermission; import org.sonar.core.util.Uuids; import org.sonar.db.DbSession; import org.sonar.db.DbTester; @@ -64,13 +64,13 @@ class RoleDaoIT { @Test void selectComponentUuidsByPermissionAndUserId_throws_IAR_if_permission_USER_is_specified() { expectUnsupportedUserAndCodeViewerPermission(() -> underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, - UserRole.USER, Uuids.createFast(), PROJECT_QUALIFIER)); + ProjectPermission.USER, Uuids.createFast(), PROJECT_QUALIFIER)); } @Test void selectComponentUuidsByPermissionAndUserId_throws_IAR_if_permission_CODEVIEWER_is_specified() { expectUnsupportedUserAndCodeViewerPermission(() -> underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, - UserRole.CODEVIEWER, Uuids.createFast(), PROJECT_QUALIFIER)); + ProjectPermission.CODEVIEWER, Uuids.createFast(), PROJECT_QUALIFIER)); } private void expectUnsupportedUserAndCodeViewerPermission(ThrowingCallable callback) { @@ -81,16 +81,16 @@ class RoleDaoIT { @Test void selectEntityIdsByPermissionAndUserUuid() { - db.users().insertProjectPermissionOnUser(user1, UserRole.ADMIN, project1); - db.users().insertProjectPermissionOnUser(user1, UserRole.ADMIN, project2); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.ADMIN, project1); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.ADMIN, project2); // global permission - not returned db.users().insertGlobalPermissionOnUser(user1, ADMINISTER); // project permission on another user id - not returned - db.users().insertProjectPermissionOnUser(user2, UserRole.ADMIN, project1); + db.users().insertProjectPermissionOnUser(user2, ProjectPermission.ADMIN, project1); // project permission on another permission - not returned - db.users().insertProjectPermissionOnUser(user1, UserRole.ISSUE_ADMIN, project1); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.ISSUE_ADMIN, project1); - List<String> entityUuids = underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, UserRole.ADMIN, user1.getUuid(), + List<String> entityUuids = underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, ProjectPermission.ADMIN, user1.getUuid(), PROJECT_QUALIFIER); assertThat(entityUuids).containsExactly(project1.getUuid(), project2.getUuid()); @@ -100,9 +100,9 @@ class RoleDaoIT { void selectComponentIdsByPermissionAndUserUuid_group_permissions() { GroupDto group1 = db.users().insertGroup(); GroupDto group2 = db.users().insertGroup(); - db.users().insertEntityPermissionOnGroup(group1, UserRole.ADMIN, project1); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.ADMIN, project1); db.users().insertMember(group1, user1); - db.users().insertProjectPermissionOnUser(user1, UserRole.ADMIN, project2); + db.users().insertProjectPermissionOnUser(user1, ProjectPermission.ADMIN, project2); // global permission - not returned db.users().insertGlobalPermissionOnUser(user1, ADMINISTER); db.users().insertPermissionOnGroup(group1, ADMINISTER); @@ -110,9 +110,9 @@ class RoleDaoIT { db.users().insertPermissionOnGroup(group2, ADMINISTER); db.users().insertMember(group2, user2); // project permission on another permission - not returned - db.users().insertEntityPermissionOnGroup(group1, UserRole.ISSUE_ADMIN, project1); + db.users().insertEntityPermissionOnGroup(group1, ProjectPermission.ISSUE_ADMIN, project1); - List<String> result = underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, UserRole.ADMIN, user1.getUuid(), + List<String> result = underTest.selectEntityUuidsByPermissionAndUserUuidAndQualifier(dbSession, ProjectPermission.ADMIN, user1.getUuid(), PROJECT_QUALIFIER); assertThat(result).containsExactlyInAnyOrder(project1.getUuid(), project2.getUuid()); |