From: Simon Brandhof <simon.brandhof@sonarsource.com>
Date: Thu, 13 Oct 2016 05:41:44 +0000 (+0200)
Subject: SONAR-8134 remove RoleDao#countComponentPermissions()
X-Git-Tag: 6.2-RC1~430
X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=0e55e8b6c465cf43959cc02c9b2c0b949829db19;p=sonarqube.git

SONAR-8134 remove RoleDao#countComponentPermissions()

replaced by GroupPermissionDao#hasRootComponentPermissions() and
 UserPermissionDao#hasRootComponentPermissions()
---

diff --git a/server/sonar-server/src/main/java/org/sonar/server/computation/task/projectanalysis/step/ApplyPermissionsStep.java b/server/sonar-server/src/main/java/org/sonar/server/computation/task/projectanalysis/step/ApplyPermissionsStep.java
index f038f98488c..f3229145c81 100644
--- a/server/sonar-server/src/main/java/org/sonar/server/computation/task/projectanalysis/step/ApplyPermissionsStep.java
+++ b/server/sonar-server/src/main/java/org/sonar/server/computation/task/projectanalysis/step/ApplyPermissionsStep.java
@@ -21,7 +21,6 @@ package org.sonar.server.computation.task.projectanalysis.step;
 
 import org.sonar.db.DbClient;
 import org.sonar.db.DbSession;
-import org.sonar.db.MyBatis;
 import org.sonar.db.permission.PermissionRepository;
 import org.sonar.server.computation.task.projectanalysis.component.Component;
 import org.sonar.server.computation.task.projectanalysis.component.CrawlerDepthLimit;
@@ -48,7 +47,7 @@ public class ApplyPermissionsStep implements ComputationStep {
   private final TreeRootHolder treeRootHolder;
 
   public ApplyPermissionsStep(DbClient dbClient, DbIdsRepository dbIdsRepository, IssueAuthorizationIndexer indexer, PermissionRepository permissionRepository,
-                              TreeRootHolder treeRootHolder) {
+    TreeRootHolder treeRootHolder) {
     this.dbClient = dbClient;
     this.dbIdsRepository = dbIdsRepository;
     this.indexer = indexer;
@@ -73,19 +72,21 @@ public class ApplyPermissionsStep implements ComputationStep {
   }
 
   private void execute(Component project) {
-    DbSession session = dbClient.openSession(false);
-    try {
+    try (DbSession dbSession = dbClient.openSession(false)) {
       long projectId = dbIdsRepository.getComponentId(project);
-      if (dbClient.roleDao().countComponentPermissions(session, projectId) == 0) {
-        permissionRepository.applyDefaultPermissionTemplate(session, projectId);
-        session.commit();
+      if (hasNoPermissions(dbSession, projectId)) {
+        permissionRepository.applyDefaultPermissionTemplate(dbSession, projectId);
+        dbSession.commit();
         indexer.index();
       }
-    } finally {
-      MyBatis.closeQuietly(session);
     }
   }
 
+  private boolean hasNoPermissions(DbSession dbSession, long projectId) {
+    return !dbClient.groupPermissionDao().hasRootComponentPermissions(dbSession, projectId) &&
+      !dbClient.userPermissionDao().hasRootComponentPermissions(dbSession, projectId);
+  }
+
   @Override
   public String getDescription() {
     return "Apply permissions";
diff --git a/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionDao.java b/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
index c1685e39776..53e579fa6c1 100644
--- a/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
+++ b/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
@@ -109,6 +109,14 @@ public class GroupPermissionDao implements Dao {
     return session.getMapper(GroupPermissionMapper.class).selectAnyonePermissions(projectId);
   }
 
+  /**
+   * @return {@code true} if the project has at least one permission defined, whatever it is
+   * on a group or on "anyone", else returns {@code false}
+   */
+  public boolean hasRootComponentPermissions(DbSession dbSession, long rootComponentId) {
+    return mapper(dbSession).countRowsByRootComponentId(rootComponentId) > 0;
+  }
+
   public void insert(DbSession dbSession, GroupPermissionDto dto) {
     mapper(dbSession).insert(dto);
   }
diff --git a/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java b/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
index 5a8138776c9..6c3978bc10e 100644
--- a/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
+++ b/sonar-db/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
@@ -64,4 +64,6 @@ public interface GroupPermissionMapper {
 
   void delete(@Param("permission") String permission, @Param("organizationUuid") String organizationUuid,
     @Nullable @Param("groupId") Long groupId, @Nullable @Param("rootComponentId") Long rootComponentId);
+
+  int countRowsByRootComponentId(@Param("rootComponentId") long rootComponentId);
 }
diff --git a/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionDao.java b/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionDao.java
index 16a21e2e6c0..648ea0afd32 100644
--- a/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionDao.java
+++ b/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionDao.java
@@ -94,6 +94,13 @@ public class UserPermissionDao implements Dao {
     return executeLargeInputs(projectIds, mapper(dbSession)::countUsersByProjectPermission);
   }
 
+  /**
+   * @return {@code true} if the project has at least one user permission defined, else returns {@code false}
+   */
+  public boolean hasRootComponentPermissions(DbSession dbSession, long rootComponentId) {
+    return mapper(dbSession).countRowsByRootComponentId(rootComponentId) > 0;
+  }
+
   public void insert(DbSession dbSession, UserPermissionDto dto) {
     mapper(dbSession).insert(dto);
   }
diff --git a/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionMapper.java b/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
index 547db6cec9e..5da6ff35ff4 100644
--- a/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
+++ b/sonar-db/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
@@ -56,4 +56,6 @@ public interface UserPermissionMapper {
    * Delete permissions by user and/or by project. In both cases scope can be restricted to a specified permission
    */
   void delete(@Nullable @Param("login") String login, @Nullable @Param("projectUuid") String projectUuid, @Nullable @Param("permission") String permission);
+
+  int countRowsByRootComponentId(@Param("rootComponentId") long projectId);
 }
diff --git a/sonar-db/src/main/java/org/sonar/db/user/RoleDao.java b/sonar-db/src/main/java/org/sonar/db/user/RoleDao.java
index 2eb62c0efc6..a09bba9ec33 100644
--- a/sonar-db/src/main/java/org/sonar/db/user/RoleDao.java
+++ b/sonar-db/src/main/java/org/sonar/db/user/RoleDao.java
@@ -44,22 +44,11 @@ public class RoleDao implements Dao {
     return session.getMapper(RoleMapper.class).selectGroupPermissions(groupName, resourceId, DefaultGroups.isAnyone(groupName));
   }
 
-  private static int countResourceGroupRoles(DbSession session, Long resourceId) {
-    return mapper(session).countResourceGroupRoles(resourceId);
-  }
-
-  private static int countResourceUserRoles(DbSession session, long resourceId) {
-    return mapper(session).countResourceUserRoles(resourceId);
-  }
 
   public void deleteGroupRolesByGroupId(DbSession session, long groupId) {
     mapper(session).deleteGroupRolesByGroupId(groupId);
   }
 
-  public int countComponentPermissions(DbSession session, Long componentId) {
-    return countResourceGroupRoles(session, componentId) + countResourceUserRoles(session, componentId);
-  }
-
   public int countUserPermissions(DbSession session, String permission, @Nullable Long allGroupsExceptThisGroupId) {
     return mapper(session).countUsersWithPermission(permission, allGroupsExceptThisGroupId);
   }
diff --git a/sonar-db/src/main/java/org/sonar/db/user/RoleMapper.java b/sonar-db/src/main/java/org/sonar/db/user/RoleMapper.java
index 23d154d5cbe..eae65a9bf34 100644
--- a/sonar-db/src/main/java/org/sonar/db/user/RoleMapper.java
+++ b/sonar-db/src/main/java/org/sonar/db/user/RoleMapper.java
@@ -35,10 +35,6 @@ public interface RoleMapper {
    */
   List<String> selectGroupPermissions(@Param("groupName") String groupName, @Nullable @Param("resourceId") Long resourceId, @Param("isAnyOneGroup") Boolean isAnyOneGroup);
 
-  int countResourceGroupRoles(Long resourceId);
-
-  int countResourceUserRoles(long resourceId);
-
   void deleteGroupRolesByGroupId(long groupId);
 
   int countUsersWithPermission(@Param("permission") String permission, @Nullable @Param("groupId") Long groupId);
diff --git a/sonar-db/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml b/sonar-db/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml
index dff26a62a71..e9c9bbb780e 100644
--- a/sonar-db/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml
+++ b/sonar-db/src/main/resources/org/sonar/db/permission/GroupPermissionMapper.xml
@@ -150,6 +150,12 @@
     </if>
   </select>
 
+  <select id="countRowsByRootComponentId" parameterType="long" resultType="int">
+    select count(1)
+    from group_roles
+    where resource_id=#{rootComponentId,jdbcType=BIGINT}
+  </select>
+
   <insert id="insert" parameterType="GroupPermission" keyColumn="id" useGeneratedKeys="true" keyProperty="id">
     insert into group_roles (
     organization_uuid,
diff --git a/sonar-db/src/main/resources/org/sonar/db/permission/UserPermissionMapper.xml b/sonar-db/src/main/resources/org/sonar/db/permission/UserPermissionMapper.xml
index b9163e08ad0..a134e797cb6 100644
--- a/sonar-db/src/main/resources/org/sonar/db/permission/UserPermissionMapper.xml
+++ b/sonar-db/src/main/resources/org/sonar/db/permission/UserPermissionMapper.xml
@@ -60,6 +60,12 @@
     group by ur.resource_id, ur.role
   </select>
 
+  <select id="countRowsByRootComponentId" parameterType="long" resultType="int">
+    select count(1)
+    from user_roles
+    where resource_id=#{rootComponentId,jdbcType=BIGINT}
+  </select>
+
   <insert id="insert" parameterType="org.sonar.db.permission.UserPermissionDto" useGeneratedKeys="false">
     insert into user_roles (
     organization_uuid,
diff --git a/sonar-db/src/main/resources/org/sonar/db/user/RoleMapper.xml b/sonar-db/src/main/resources/org/sonar/db/user/RoleMapper.xml
index 0ac0d435512..766ae4a6bf7 100644
--- a/sonar-db/src/main/resources/org/sonar/db/user/RoleMapper.xml
+++ b/sonar-db/src/main/resources/org/sonar/db/user/RoleMapper.xml
@@ -49,16 +49,6 @@
     </where>
   </select>
 
-  <select id="countResourceUserRoles" parameterType="long" resultType="int">
-    SELECT count(1)
-    FROM user_roles WHERE resource_id=#{id}
-  </select>
-
-  <select id="countResourceGroupRoles" parameterType="long" resultType="int">
-    SELECT count(1)
-    FROM group_roles WHERE resource_id=#{id}
-  </select>
-
   <select id="countUsersWithPermission" parameterType="map" resultType="int">
     SELECT count(c.id)
     FROM (
diff --git a/sonar-db/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java b/sonar-db/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java
index 014fafcbb69..453e05bce37 100644
--- a/sonar-db/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java
+++ b/sonar-db/src/test/java/org/sonar/db/permission/GroupPermissionDaoTest.java
@@ -316,6 +316,33 @@ public class GroupPermissionDaoTest {
     assertThat(underTest.selectAnyonePermissions(dbSession, UNKNOWN_PROJECT_ID)).isEmpty();
   }
 
+  @Test
+  public void projectHasPermissions_is_false_if_no_permissions_at_all() {
+    ComponentDto project1 = db.components().insertProject();
+    db.users().insertPermissionOnAnyone("perm1");
+
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project1.getId())).isFalse();
+  }
+
+  @Test
+  public void projectHasPermissions_is_true_if_at_least_one_permission_on_group() {
+    GroupDto group1 = db.users().insertGroup(newGroupDto());
+    ComponentDto project1 = db.components().insertProject();
+    db.users().insertProjectPermissionOnGroup(group1, "perm1", project1);
+
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project1.getId())).isTrue();
+  }
+
+  @Test
+  public void projectHasPermissions_is_true_if_at_least_one_permission_on_anyone() {
+    ComponentDto project1 = db.components().insertProject();
+    ComponentDto project2 = db.components().insertProject();
+    db.users().insertProjectPermissionOnAnyone("perm1", project1);
+
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project1.getId())).isTrue();
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project2.getId())).isFalse();
+  }
+
   @Test
   public void deleteByRootComponentId() {
     GroupDto group1 = db.users().insertGroup(newGroupDto());
diff --git a/sonar-db/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java b/sonar-db/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java
index 6b9f7a6f708..e056456ec4a 100644
--- a/sonar-db/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java
+++ b/sonar-db/src/test/java/org/sonar/db/permission/UserPermissionDaoTest.java
@@ -28,6 +28,8 @@ import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.utils.System2;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
 import org.sonar.db.DbTester;
 import org.sonar.db.component.ComponentDto;
 import org.sonar.db.user.UserDto;
@@ -52,14 +54,16 @@ public class UserPermissionDaoTest {
   private UserDto user3 = newUserDto().setLogin("login3").setName("Bernard").setActive(true);
   private ComponentDto project1 = newProjectDto();
   private ComponentDto project2 = newProjectDto();
+  private DbSession dbSession = dbTester.getSession();
 
   @Before
   public void setUp() throws Exception {
-    dbTester.getDbClient().userDao().insert(dbTester.getSession(), user1);
-    dbTester.getDbClient().userDao().insert(dbTester.getSession(), user2);
-    dbTester.getDbClient().userDao().insert(dbTester.getSession(), user3);
-    dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project1);
-    dbTester.getDbClient().componentDao().insert(dbTester.getSession(), project2);
+    DbClient dbClient = dbTester.getDbClient();
+    dbClient.userDao().insert(dbSession, user1);
+    dbClient.userDao().insert(dbSession, user2);
+    dbClient.userDao().insert(dbSession, user3);
+    dbClient.componentDao().insert(dbSession, project1);
+    dbClient.componentDao().insert(dbSession, project2);
     dbTester.commit();
   }
 
@@ -188,7 +192,7 @@ public class UserPermissionDaoTest {
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project2.getId());
 
     // no projects -> return empty list
-    assertThat(underTest.countUsersByProjectPermission(dbTester.getSession(), Collections.emptyList())).isEmpty();
+    assertThat(underTest.countUsersByProjectPermission(dbSession, Collections.emptyList())).isEmpty();
 
     // one project
     expectCount(asList(project1.getId()),
@@ -211,12 +215,12 @@ public class UserPermissionDaoTest {
 
     // logins are ordered by user name: user2 ("Marie") then user1 ("Marius")
     PermissionQuery query = PermissionQuery.builder().setComponentUuid(project1.uuid()).withAtLeastOnePermission().build();
-    List<String> logins = underTest.selectLogins(dbTester.getSession(), query);
+    List<String> logins = underTest.selectLogins(dbSession, query);
     assertThat(logins).containsExactly(user2.getLogin(), user1.getLogin());
 
     // on a project without permissions
     query = PermissionQuery.builder().setComponentUuid("missing").withAtLeastOnePermission().build();
-    assertThat(underTest.selectLogins(dbTester.getSession(), query)).isEmpty();
+    assertThat(underTest.selectLogins(dbSession, query)).isEmpty();
   }
 
   @Test
@@ -228,18 +232,18 @@ public class UserPermissionDaoTest {
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project2.getId());
 
     // user1 has one global permission and user2 has no global permissions
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), user1.getLogin(), null)).hasSize(1);
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), user2.getLogin(), null)).hasSize(0);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, user1.getLogin(), null)).hasSize(1);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, user2.getLogin(), null)).hasSize(0);
 
     // user1 has one permission on project1, user2 has 2
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), user1.getLogin(), project1.uuid())).hasSize(1);
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), user2.getLogin(), project1.uuid())).hasSize(2);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, user1.getLogin(), project1.uuid())).hasSize(1);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, user2.getLogin(), project1.uuid())).hasSize(2);
 
     // nobody has permissions on a project that does not exist!
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), user1.getLogin(), "missing")).hasSize(0);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, user1.getLogin(), "missing")).hasSize(0);
 
     // users who do not exist don't have permissions!
-    assertThat(underTest.selectPermissionsByLogin(dbTester.getSession(), "missing", null)).hasSize(0);
+    assertThat(underTest.selectPermissionsByLogin(dbSession, "missing", null)).hasSize(0);
   }
 
   @Test
@@ -249,11 +253,11 @@ public class UserPermissionDaoTest {
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project1.getId());
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project2.getId());
 
-    underTest.delete(dbTester.getSession(), null, project1.uuid(), null);
+    underTest.delete(dbSession, null, project1.uuid(), null);
 
-    assertThat(dbTester.countSql(dbTester.getSession(), "select count(id) from user_roles where resource_id=" + project1.getId())).isEqualTo(0);
+    assertThat(dbTester.countSql(dbSession, "select count(id) from user_roles where resource_id=" + project1.getId())).isEqualTo(0);
     // remains global permission and project2 permission
-    assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "user_roles")).isEqualTo(2);
+    assertThat(dbTester.countRowsOfTable(dbSession, "user_roles")).isEqualTo(2);
   }
 
   @Test
@@ -263,11 +267,11 @@ public class UserPermissionDaoTest {
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project1.getId());
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project2.getId());
 
-    underTest.delete(dbTester.getSession(), user1.getLogin(), null, null);
+    underTest.delete(dbSession, user1.getLogin(), null, null);
 
-    assertThat(dbTester.countSql(dbTester.getSession(), "select count(id) from user_roles where user_id=" + user1.getId())).isEqualTo(0);
+    assertThat(dbTester.countSql(dbSession, "select count(id) from user_roles where user_id=" + user1.getId())).isEqualTo(0);
     // remains user2 permissions
-    assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "user_roles")).isEqualTo(2);
+    assertThat(dbTester.countRowsOfTable(dbSession, "user_roles")).isEqualTo(2);
   }
 
   @Test
@@ -277,15 +281,24 @@ public class UserPermissionDaoTest {
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project1.getId());
     insertProjectPermission(ISSUE_ADMIN, user2.getId(), project2.getId());
 
-    underTest.delete(dbTester.getSession(), user1.getLogin(), project1.uuid(), USER);
+    underTest.delete(dbSession, user1.getLogin(), project1.uuid(), USER);
 
-    assertThat(dbTester.countRowsOfTable(dbTester.getSession(), "user_roles")).isEqualTo(3);
-    assertThat(dbTester.countSql(dbTester.getSession(), "select count(id) from user_roles where user_id=" + user1.getId())).isEqualTo(1);
-    assertThat(dbTester.countSql(dbTester.getSession(), "select count(id) from user_roles where role='" + SYSTEM_ADMIN + "' and user_id=" + user1.getId())).isEqualTo(1);
+    assertThat(dbTester.countRowsOfTable(dbSession, "user_roles")).isEqualTo(3);
+    assertThat(dbTester.countSql(dbSession, "select count(id) from user_roles where user_id=" + user1.getId())).isEqualTo(1);
+    assertThat(dbTester.countSql(dbSession, "select count(id) from user_roles where role='" + SYSTEM_ADMIN + "' and user_id=" + user1.getId())).isEqualTo(1);
+  }
+
+  @Test
+  public void projectHasPermissions() {
+    insertGlobalPermission(SYSTEM_ADMIN, user1.getId());
+    insertProjectPermission(USER, user1.getId(), project1.getId());
+
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project1.getId())).isTrue();
+    assertThat(underTest.hasRootComponentPermissions(dbSession, project2.getId())).isFalse();
   }
 
   private void expectCount(List<Long> projectIds, CountPerProjectPermission... expected) {
-    List<CountPerProjectPermission> got = underTest.countUsersByProjectPermission(dbTester.getSession(), projectIds);
+    List<CountPerProjectPermission> got = underTest.countUsersByProjectPermission(dbSession, projectIds);
     assertThat(got).hasSize(expected.length);
 
     for (CountPerProjectPermission expect : expected) {
@@ -298,7 +311,7 @@ public class UserPermissionDaoTest {
 
   private void expectPermissions(PermissionQuery query, @Nullable Collection<String> logins, UserPermissionDto... expected) {
     // test method "select()"
-    List<ExtendedUserPermissionDto> permissions = underTest.select(dbTester.getSession(), query, logins);
+    List<ExtendedUserPermissionDto> permissions = underTest.select(dbSession, query, logins);
     assertThat(permissions).hasSize(expected.length);
     for (int i = 0; i < expected.length; i++) {
       ExtendedUserPermissionDto got = permissions.get(i);
@@ -315,20 +328,20 @@ public class UserPermissionDaoTest {
     if (logins == null) {
       // test method "countUsers()", which does not make sense if users are filtered
       long distinctUsers = Arrays.stream(expected).mapToLong(p -> p.getUserId()).distinct().count();
-      assertThat((long) underTest.countUsers(dbTester.getSession(), query)).isEqualTo(distinctUsers);
+      assertThat((long) underTest.countUsers(dbSession, query)).isEqualTo(distinctUsers);
     }
   }
 
   private UserPermissionDto insertGlobalPermission(String permission, long userId) {
     UserPermissionDto dto = new UserPermissionDto(dbTester.getDefaultOrganization().getUuid(), permission, userId, null);
-    underTest.insert(dbTester.getSession(), dto);
+    underTest.insert(dbSession, dto);
     dbTester.commit();
     return dto;
   }
 
   private UserPermissionDto insertProjectPermission(String permission, long userId, long projectId) {
     UserPermissionDto dto = new UserPermissionDto(dbTester.getDefaultOrganization().getUuid(), permission, userId, projectId);
-    underTest.insert(dbTester.getSession(), dto);
+    underTest.insert(dbSession, dto);
     dbTester.commit();
     return dto;
   }
diff --git a/sonar-db/src/test/java/org/sonar/db/user/RoleDaoTest.java b/sonar-db/src/test/java/org/sonar/db/user/RoleDaoTest.java
index 843cd398aa9..08a880b03c6 100644
--- a/sonar-db/src/test/java/org/sonar/db/user/RoleDaoTest.java
+++ b/sonar-db/src/test/java/org/sonar/db/user/RoleDaoTest.java
@@ -126,13 +126,6 @@ public class RoleDaoTest {
     db.assertDbUnit(getClass(), "deleteGroupPermissionsByGroupId-result.xml", "group_roles");
   }
 
-  @Test
-  public void should_count_component_permissions() {
-    db.prepareDbUnit(getClass(), "should_count_component_permissions.xml");
-
-    assertThat(underTest.countComponentPermissions(db.getSession(), 123L)).isEqualTo(2);
-  }
-
   @Test
   public void countUserPermissions() {
     db.users().insertProjectPermissionOnUser(user1, GlobalPermissions.SYSTEM_ADMIN, project1);
diff --git a/sonar-db/src/test/java/org/sonar/db/user/RoleMapperTest.java b/sonar-db/src/test/java/org/sonar/db/user/RoleMapperTest.java
deleted file mode 100644
index 50d7555047c..00000000000
--- a/sonar-db/src/test/java/org/sonar/db/user/RoleMapperTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * SonarQube
- * Copyright (C) 2009-2016 SonarSource SA
- * mailto:contact 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.user;
-
-import org.junit.Rule;
-import org.junit.Test;
-import org.sonar.api.utils.System2;
-import org.sonar.db.DbTester;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class RoleMapperTest {
-
-  @Rule
-  public DbTester dbTester = DbTester.create(System2.INSTANCE);
-
-  @Test
-  public void count_roles() {
-    dbTester.prepareDbUnit(getClass(), "countRoles.xml");
-
-    RoleMapper mapper = dbTester.getSession().getMapper(RoleMapper.class);
-    assertThat(mapper.countResourceGroupRoles(123L)).isEqualTo(2);
-    assertThat(mapper.countResourceUserRoles(123L)).isEqualTo(1);
-  }
-
-}
diff --git a/sonar-db/src/test/resources/org/sonar/db/user/RoleDaoTest/should_count_component_permissions.xml b/sonar-db/src/test/resources/org/sonar/db/user/RoleDaoTest/should_count_component_permissions.xml
deleted file mode 100644
index 3c91825413a..00000000000
--- a/sonar-db/src/test/resources/org/sonar/db/user/RoleDaoTest/should_count_component_permissions.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<dataset>
-
-  <users id="200"
-         login="dave.loper"
-         name="Dave Loper"
-         email="dave.loper@company.net"
-         active="[true]"
-         is_root="[false]"/>
-
-  <groups id="100"
-          name="devs"
-          organization_uuid="org1"/>
-
-  <user_roles id="1"
-              user_id="200"
-              resource_id="123"
-              role="user"
-              organization_uuid="org1"/>
-
-  <group_roles id="1"
-               group_id="100"
-               resource_id="123"
-               role="codeviewer"
-               organization_uuid="org1"/>
-
-</dataset>
diff --git a/sonar-db/src/test/resources/org/sonar/db/user/RoleMapperTest/countRoles.xml b/sonar-db/src/test/resources/org/sonar/db/user/RoleMapperTest/countRoles.xml
deleted file mode 100644
index c0e35675070..00000000000
--- a/sonar-db/src/test/resources/org/sonar/db/user/RoleMapperTest/countRoles.xml
+++ /dev/null
@@ -1,43 +0,0 @@
-<dataset>
-  <groups id="100"
-          name="sonar-administrators"
-          organization_uuid="org1"/>
-  <groups id="101"
-          name="sonar-users"
-          organization_uuid="org1"/>
-  <users id="200"
-         login="marius"
-         name="Marius"
-         email="[null]"
-         active="[true]"
-         is_root="[false]"/>
-
-  <group_roles id="1"
-               group_id="100"
-               resource_id="123"
-               role="admin"
-               organization_uuid="org1"/>
-  <group_roles id="2"
-               group_id="[null]"
-               resource_id="123"
-               role="user"
-               organization_uuid="org1"/>
-  <user_roles id="1"
-              user_id="200"
-              resource_id="123"
-              role="codeviewer"
-              organization_uuid="org1"/>
-
-  <!-- other resource -->
-  <group_roles id="3"
-               group_id="101"
-               resource_id="999"
-               role="codeviewer"
-               organization_uuid="org1"/>
-  <user_roles id="2"
-              user_id="200"
-              resource_id="999"
-              role="codeviewer"
-              organization_uuid="org1"/>
-
-</dataset>