SONAR-6476 SONAr-6477 Apply feedback from PR

1 files changed, 77 insertions, 125 deletions

diff --git a/sonar-core/src/test/java/org/sonar/core/user/GroupMembershipDaoTest.java b/sonar-core/src/test/java/org/sonar/core/user/GroupMembershipDaoTest.java
index 8b8992f07f0..e2b45132d91 100644
--- a/sonar-core/src/test/java/org/sonar/core/user/GroupMembershipDaoTest.java
+++ b/sonar-core/src/test/java/org/sonar/core/user/GroupMembershipDaoTest.java
@@ -23,12 +23,14 @@ package org.sonar.core.user;
 import com.google.common.collect.Multimap;
 import java.util.Arrays;
 import java.util.List;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.ClassRule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.sonar.core.persistence.DbSession;
 import org.sonar.core.persistence.DbTester;
+import org.sonar.core.persistence.MyBatis;
 import org.sonar.test.DbTests;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -42,10 +44,18 @@ public class GroupMembershipDaoTest {
 
   private GroupMembershipDao dao;
 
+  private DbSession dbSession;
+
   @Before
   public void setUp() {
     dbTester.truncateTables();
     dao = new GroupMembershipDao(dbTester.myBatis());
+    dbSession = dbTester.myBatis().openSession(false);
+  }
+
+  @After
+  public void tearDown() {
+    MyBatis.closeQuietly(dbSession);
   }
 
   @Test
@@ -155,154 +165,108 @@ public class GroupMembershipDaoTest {
   @Test
   public void count_groups() {
     dbTester.prepareDbUnit(getClass(), "shared.xml");
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      // 200 is member of 3 groups
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200L)).isEqualTo(3);
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200L)).isZero();
-      // 201 is member of 1 group on 3
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201L)).isEqualTo(1);
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201L)).isEqualTo(2);
-      // 999 is member of 0 group
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999L)).isZero();
-      assertThat(dao.countGroups(session, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999L)).isEqualTo(3);
-    } finally {
-      session.close();
-    }
+
+    // 200 is member of 3 groups
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200L)).isEqualTo(3);
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200L)).isZero();
+    // 201 is member of 1 group on 3
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201L)).isEqualTo(1);
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201L)).isEqualTo(2);
+    // 999 is member of 0 group
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999L)).isZero();
+    assertThat(dao.countGroups(dbSession, GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999L)).isEqualTo(3);
   }
 
   @Test
   public void count_users_by_group() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      assertThat(dao.countUsersByGroups(session, Arrays.asList(100L, 101L, 102L, 103L))).containsOnly(
-        entry("sonar-users", 2), entry("sonar-reviewers", 1), entry("sonar-administrators", 1), entry("sonar-nobody", 0));
-      assertThat(dao.countUsersByGroups(session, Arrays.asList(100L, 103L))).containsOnly(
-        entry("sonar-administrators", 1), entry("sonar-nobody", 0));
-    } finally {
-      session.close();
-    }
+
+    assertThat(dao.countUsersByGroups(dbSession, Arrays.asList(100L, 101L, 102L, 103L))).containsOnly(
+      entry("sonar-users", 2), entry("sonar-reviewers", 1), entry("sonar-administrators", 1), entry("sonar-nobody", 0));
+    assertThat(dao.countUsersByGroups(dbSession, Arrays.asList(100L, 103L))).containsOnly(
+      entry("sonar-administrators", 1), entry("sonar-nobody", 0));
   }
 
   @Test
   public void count_groups_by_login() {
     dbTester.prepareDbUnit(getClass(), "shared.xml");
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      assertThat(dao.selectGroupsByLogins(session, Arrays.<String>asList()).keys()).isEmpty();
-      Multimap<String, String> groupsByLogin = dao.selectGroupsByLogins(session, Arrays.asList("two-hundred", "two-hundred-one", "two-hundred-two"));
-      assertThat(groupsByLogin.get("two-hundred")).containsOnly("sonar-administrators", "sonar-users", "sonar-reviewers");
-      assertThat(groupsByLogin.get("two-hundred-one")).containsOnly("sonar-users");
-      assertThat(groupsByLogin.get("two-hundred-two")).isEmpty();
-    } finally {
-      session.close();
-    }
+
+    assertThat(dao.selectGroupsByLogins(dbSession, Arrays.<String>asList()).keys()).isEmpty();
+    Multimap<String, String> groupsByLogin = dao.selectGroupsByLogins(dbSession, Arrays.asList("two-hundred", "two-hundred-one", "two-hundred-two"));
+    assertThat(groupsByLogin.get("two-hundred")).containsOnly("sonar-administrators", "sonar-users", "sonar-reviewers");
+    assertThat(groupsByLogin.get("two-hundred-one")).containsOnly("sonar-users");
+    assertThat(groupsByLogin.get("two-hundred-two")).isEmpty();
   }
 
   @Test
   public void count_members() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
-    DbSession session = dbTester.myBatis().openSession(false);
 
-    try {
-      // 100 has 1 member and 1 non member
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
-      // 101 has 2 members
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build())).isZero();
-      // 102 has 1 member and 1 non member
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
-      // 103 has no member
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build())).isZero();
-      assertThat(dao.countMembers(session, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
-    } finally {
-      session.close();
-    }
+    // 100 has 1 member and 1 non member
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+    // 101 has 2 members
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build())).isZero();
+    // 102 has 1 member and 1 non member
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+    // 103 has no member
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build())).isZero();
+    assertThat(dao.countMembers(dbSession, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
   }
 
   @Test
   public void select_group_members_by_query() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      // 100 has 1 member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
-      // 101 has 2 members
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
-      // 102 has 1 member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
-      // 103 has no member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty();
-    } finally {
-      session.close();
-    }
+    // 100 has 1 member
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+    // 101 has 2 members
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
+    // 102 has 1 member
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+    // 103 has no member
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty();
   }
 
   @Test
   public void select_users_not_affected_to_a_group_by_query() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
       // 100 has 1 member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
       // 101 has 2 members
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(101L).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
       // 102 has 1 member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(102L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
       // 103 has no member
-      assertThat(dao.selectMembers(session, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2);
-    } finally {
-      session.close();
-    }
+    assertThat(dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(103L).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2);
   }
 
   @Test
   public void search_by_user_name_or_login() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-
-      List<UserMembershipDto> result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).memberSearch("admin").build(), 0, 10);
-      assertThat(result).hasSize(2);
+    List<UserMembershipDto> result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).memberSearch("admin").build(), 0, 10);
+    assertThat(result).hasSize(2);
 
-      assertThat(result.get(0).getName()).isEqualTo("Admin");
-      assertThat(result.get(1).getName()).isEqualTo("Not Admin");
+    assertThat(result.get(0).getName()).isEqualTo("Admin");
+    assertThat(result.get(1).getName()).isEqualTo("Not Admin");
 
-      result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).memberSearch("not").build(), 0, 10);
+    result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).memberSearch("not").build(), 0, 10);
       assertThat(result).hasSize(1);
-
-    } finally {
-      session.close();
-    }
   }
 
   @Test
   public void search_by_login_or_name_with_capitalization() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      List<UserMembershipDto> result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).memberSearch("admin").build(), 0, 10);
-      assertThat(result).hasSize(2);
+    List<UserMembershipDto> result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).memberSearch("admin").build(), 0, 10);
+    assertThat(result).hasSize(2);
 
-      result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).memberSearch("AdMiN").build(), 0, 10);
-      assertThat(result).hasSize(2);
-    } finally {
-      session.close();
-    }
+    result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).memberSearch("AdMiN").build(), 0, 10);
+    assertThat(result).hasSize(2);
 
   }
 
@@ -310,38 +274,26 @@ public class GroupMembershipDaoTest {
   public void should_be_sorted_by_user_name() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      List<UserMembershipDto> result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).build(), 0, 10);
-      assertThat(result).hasSize(2);
-      assertThat(result.get(0).getName()).isEqualTo("Admin");
-      assertThat(result.get(1).getName()).isEqualTo("Not Admin");
-    } finally {
-      session.close();
-    }
+    List<UserMembershipDto> result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).build(), 0, 10);
+    assertThat(result).hasSize(2);
+    assertThat(result.get(0).getName()).isEqualTo("Admin");
+    assertThat(result.get(1).getName()).isEqualTo("Not Admin");
   }
 
   @Test
   public void members_should_be_paginated() {
     dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
 
-    DbSession session = dbTester.myBatis().openSession(false);
-
-    try {
-      List<UserMembershipDto> result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).build(), 0, 2);
-      assertThat(result).hasSize(2);
-      assertThat(result.get(0).getName()).isEqualTo("Admin");
-      assertThat(result.get(1).getName()).isEqualTo("Not Admin");
+    List<UserMembershipDto> result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).build(), 0, 2);
+    assertThat(result).hasSize(2);
+    assertThat(result.get(0).getName()).isEqualTo("Admin");
+    assertThat(result.get(1).getName()).isEqualTo("Not Admin");
 
-      result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).build(), 1, 2);
-      assertThat(result).hasSize(1);
-      assertThat(result.get(0).getName()).isEqualTo("Not Admin");
+    result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).build(), 1, 2);
+    assertThat(result).hasSize(1);
+    assertThat(result.get(0).getName()).isEqualTo("Not Admin");
 
-      result = dao.selectMembers(session, UserMembershipQuery.builder().groupId(100L).build(), 2, 1);
-      assertThat(result).isEmpty();
-    } finally {
-      session.close();
-    }
+    result = dao.selectMembers(dbSession, UserMembershipQuery.builder().groupId(100L).build(), 2, 1);
+    assertThat(result).isEmpty();
   }
 }