SONAR-8968 Remove DbUnit usage in GroupMembershipDaoTest

diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java
index 2f43d70e29b9ba8a90c87c027670561b51432199..bbbc0a509dee6ade5683c634874aa49e691ab63a 100644 (file)
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupMembershipDaoTest.java
@@ -20,139 +20,220 @@
 package org.sonar.db.user;
 
 import com.google.common.collect.Multimap;
-import java.util.Arrays;
 import java.util.List;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.sonar.api.utils.System2;
 import org.sonar.db.DbTester;
+import org.sonar.db.organization.OrganizationDto;
 
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.data.MapEntry.entry;
+import static org.sonar.db.user.GroupMembershipQuery.IN;
+import static org.sonar.db.user.GroupMembershipQuery.OUT;
+import static org.sonar.db.user.GroupMembershipQuery.builder;
+import static org.sonar.db.user.UserTesting.newDisabledUser;
+import static org.sonar.db.user.UserTesting.newUserDto;
 
 public class GroupMembershipDaoTest {
 
   @Rule
-  public DbTester dbTester = DbTester.create(System2.INSTANCE);
+  public DbTester db = DbTester.create();
 
-  private GroupMembershipDao underTest = dbTester.getDbClient().groupMembershipDao();
+  private OrganizationDto organizationDto;
+  private UserDto user1;
+  private UserDto user2;
+  private UserDto user3;
+  private GroupDto group1;
+  private GroupDto group2;
+  private GroupDto group3;
+
+  private GroupMembershipDao underTest = db.getDbClient().groupMembershipDao();
+
+  @Before
+  public void setUp() throws Exception {
+    organizationDto = db.organizations().insert();
+    user1 = db.users().insertUser(newUserDto("admin login", "Admin name", "admin@email.com"));
+    user2 = db.users().insertUser(newUserDto("not.admin", "Not Admin", "Not Admin"));
+    user3 = db.users().insertUser(newDisabledUser("inactive"));
+    group1 = db.users().insertGroup(organizationDto, "sonar-administrators");
+    group2 = db.users().insertGroup(organizationDto, "sonar-users");
+    group3 = db.users().insertGroup(organizationDto, "sonar-reviewers");
+  }
 
   @Test
   public void count_groups() {
-    dbTester.prepareDbUnit(getClass(), "shared.xml");
-
-    // 200 is member of 3 groups
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 200)).isEqualTo(3);
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 200)).isZero();
-    // 201 is member of 1 group on 3
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 201)).isEqualTo(1);
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 201)).isEqualTo(2);
-    // 999 is member of 0 group
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.IN).build(), 999)).isZero();
-    assertThat(underTest.countGroups(dbTester.getSession(), GroupMembershipQuery.builder().login("arthur").membership(GroupMembershipQuery.OUT).build(), 2999)).isEqualTo(3);
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
+
+    // user1 is member of 3 groups
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user1.getId())).isEqualTo(3);
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user1.getId())).isZero();
+    // user2 is member of 1 group on 3
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user2.getId())).isEqualTo(1);
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user2.getId())).isEqualTo(2);
+    // user3 is member of 0 group
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user3.getId())).isZero();
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user3.getId())).isEqualTo(3);
+    // unknown user is member of 0 group
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(IN).build(), 999)).isZero();
+    assertThat(underTest.countGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), 999)).isEqualTo(3);
+  }
+
+  @Test
+  public void select_groups() {
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
+
+    // user1 is member of 3 groups
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user1.getId(), 0, 10)).hasSize(3);
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user1.getId(), 0, 10)).isEmpty();
+    // user2 is member of 1 group on 3
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user2.getId(), 0, 10)).hasSize(1);
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user2.getId(), 0, 10)).hasSize(2);
+    // user3 is member of 0 group
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(IN).build(), user3.getId(), 0, 10)).isEmpty();
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), user3.getId(), 0, 10)).hasSize(3);
+    // unknown user is member of 0 group
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(IN).build(), 999, 0, 10)).isEmpty();
+    assertThat(underTest.selectGroups(db.getSession(), builder().login("arthur").membership(OUT).build(), 999, 0, 10)).hasSize(3);
   }
 
   @Test
   public void count_users_by_group() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    GroupDto emptyGroup = db.users().insertGroup(organizationDto, "sonar-nobody");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
-    assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100, 101, 102, 103))).containsOnly(
-      entry("sonar-users", 2), entry("sonar-reviewers", 1), entry("sonar-administrators", 1), entry("sonar-nobody", 0));
-    assertThat(underTest.countUsersByGroups(dbTester.getSession(), Arrays.asList(100, 103))).containsOnly(
-      entry("sonar-administrators", 1), entry("sonar-nobody", 0));
+    assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getId(), group2.getId(), group3.getId(), emptyGroup.getId())))
+      .containsOnly(entry(group1.getName(), 1), entry(group2.getName(), 2), entry(group3.getName(), 1), entry(emptyGroup.getName(), 0));
+    assertThat(underTest.countUsersByGroups(db.getSession(), asList(group1.getId(), emptyGroup.getId())))
+      .containsOnly(entry(group1.getName(), 1), entry(emptyGroup.getName(), 0));
   }
 
   @Test
   public void count_groups_by_logins() {
-    dbTester.prepareDbUnit(getClass(), "shared.xml");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
-    assertThat(underTest.selectGroupsByLogins(dbTester.getSession(), Arrays.<String>asList()).keys()).isEmpty();
-    Multimap<String, String> groupsByLogin = underTest.selectGroupsByLogins(dbTester.getSession(), Arrays.asList("two-hundred", "two-hundred-one", "two-hundred-two"));
-    assertThat(groupsByLogin.get("two-hundred")).containsExactly("sonar-administrators", "sonar-reviewers", "sonar-users");
-    assertThat(groupsByLogin.get("two-hundred-one")).containsExactly("sonar-users");
-    assertThat(groupsByLogin.get("two-hundred-two")).isEmpty();
+    assertThat(underTest.selectGroupsByLogins(db.getSession(), emptyList()).keys()).isEmpty();
+    Multimap<String, String> groupsByLogin = underTest.selectGroupsByLogins(db.getSession(), asList(user1.getLogin(), user2.getLogin(), user3.getLogin()));
+    assertThat(groupsByLogin.get(user1.getLogin())).containsOnly(group1.getName(), group2.getName(), group3.getName());
+    assertThat(groupsByLogin.get(user2.getLogin())).containsOnly(group2.getName());
+    assertThat(groupsByLogin.get(user3.getLogin())).isEmpty();
   }
 
   @Test
   public void count_members() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    GroupDto emptyGroup = db.users().insertGroup(organizationDto, "sonar-nobody");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
     // 100 has 1 member and 1 non member
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
     // 101 has 2 members
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.OUT).build())).isZero();
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group2.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(2);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group2.getId()).membership(UserMembershipQuery.OUT).build())).isZero();
     // 102 has 1 member and 1 non member
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group3.getId()).membership(UserMembershipQuery.IN).build())).isEqualTo(1);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(group3.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(1);
     // 103 has no member
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.IN).build())).isZero();
-    assertThat(underTest.countMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(emptyGroup.getId()).membership(UserMembershipQuery.IN).build())).isZero();
+    assertThat(underTest.countMembers(db.getSession(), UserMembershipQuery.builder().groupId(emptyGroup.getId()).membership(UserMembershipQuery.OUT).build())).isEqualTo(2);
   }
 
   @Test
   public void select_group_members_by_query() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    GroupDto emptyGroup = db.users().insertGroup(organizationDto, "sonar-nobody");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
     // 100 has 1 member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
     // 101 has 2 members
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group2.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(2);
     // 102 has 1 member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group3.getId()).membership(UserMembershipQuery.IN).build(), 0, 10)).hasSize(1);
     // 103 has no member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.IN).build(), 0, 10)).isEmpty();
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(emptyGroup.getId()).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");
+    GroupDto emptyGroup = db.users().insertGroup(organizationDto, "sonar-nobody");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
     // 100 has 1 member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
     // 101 has 2 members
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(101).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group2.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).isEmpty();
     // 102 has 1 member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(102).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group3.getId()).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(1);
     // 103 has no member
-    assertThat(underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(103).membership(UserMembershipQuery.OUT).build(), 0, 10)).hasSize(2);
+    assertThat(underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(emptyGroup.getId()).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");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
-    List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("admin").build(), 0, 10);
+    List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).memberSearch("admin").build(), 0, 10);
     assertThat(result).hasSize(2);
 
     assertThat(result.get(0).getName()).isEqualTo("Admin name");
     assertThat(result.get(1).getName()).isEqualTo("Not Admin");
 
-    result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("not").build(), 0, 10);
+    result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).memberSearch("not").build(), 0, 10);
     assertThat(result).hasSize(1);
   }
 
   @Test
   public void search_by_login_name_or_email() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
     // search is case insensitive only on name
-    List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("NaMe").build(), 0, 10);
+    List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).memberSearch("NaMe").build(), 0, 10);
     assertThat(result).hasSize(1);
 
-    result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("login").build(), 0, 10);
+    result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).memberSearch("login").build(), 0, 10);
     assertThat(result).hasSize(1);
 
-    result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).memberSearch("email").build(), 0, 10);
+    result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).memberSearch("email").build(), 0, 10);
     assertThat(result).hasSize(1);
   }
 
   @Test
   public void should_be_sorted_by_user_name() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
-    List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 0, 10);
+    List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).build(), 0, 10);
     assertThat(result).hasSize(2);
     assertThat(result.get(0).getName()).isEqualTo("Admin name");
     assertThat(result.get(1).getName()).isEqualTo("Not Admin");
@@ -160,18 +241,21 @@ public class GroupMembershipDaoTest {
 
   @Test
   public void members_should_be_paginated() {
-    dbTester.prepareDbUnit(getClass(), "shared_plus_empty_group.xml");
+    db.users().insertMember(group1, user1);
+    db.users().insertMember(group2, user1);
+    db.users().insertMember(group3, user1);
+    db.users().insertMember(group2, user2);
 
-    List<UserMembershipDto> result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 0, 2);
+    List<UserMembershipDto> result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(group1.getId()).build(), 0, 2);
     assertThat(result).hasSize(2);
     assertThat(result.get(0).getName()).isEqualTo("Admin name");
     assertThat(result.get(1).getName()).isEqualTo("Not Admin");
 
-    result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 1, 2);
+    result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(100).build(), 1, 2);
     assertThat(result).hasSize(1);
     assertThat(result.get(0).getName()).isEqualTo("Not Admin");
 
-    result = underTest.selectMembers(dbTester.getSession(), UserMembershipQuery.builder().groupId(100).build(), 2, 1);
+    result = underTest.selectMembers(db.getSession(), UserMembershipQuery.builder().groupId(100).build(), 2, 1);
     assertThat(result).isEmpty();
   }
 }

diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/select_user_group.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/select_user_group.xml
deleted file mode 100644 (file)
index a1aa720..0000000
--- a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/select_user_group.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<dataset>
-
-  <groups id="101"
-          name="sonar-users"
-          description="Any new users created will automatically join this group"
-          organization_uuid="org1"/>
-
-  <groups_users user_id="201"
-                group_id="101"/>
-
-</dataset>

diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared.xml
deleted file mode 100644 (file)
index 425e2ed..0000000
--- a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<dataset>
-
-  <groups id="100"
-          name="sonar-administrators"
-          description="System administrators"
-          organization_uuid="org1"/>
-  <groups id="101"
-          name="sonar-users"
-          description="Any new users created will automatically join this group"
-          organization_uuid="org1"/>
-  <groups id="102"
-          name="sonar-reviewers"
-          description="Reviewers"
-          organization_uuid="org1"/>
-
-  <!-- user 200 is in all groups -->
-  <groups_users user_id="200"
-                group_id="100"/>
-  <groups_users user_id="200"
-                group_id="101"/>
-  <groups_users user_id="200"
-                group_id="102"/>
-
-  <!-- user 201 is in users group -->
-  <groups_users user_id="201"
-                group_id="101"/>
-
-  <users id="200"
-         login="two-hundred"
-         is_root="[false]"/>
-  <users id="201"
-         login="two-hundred-one"
-         is_root="[false]"/>
-  <users id="202"
-         login="two-hundred-two"
-         is_root="[false]"/>
-
-</dataset>

diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared_plus_empty_group.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared_plus_empty_group.xml
deleted file mode 100644 (file)
index a475bba..0000000
--- a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/shared_plus_empty_group.xml
+++ /dev/null
@@ -1,50 +0,0 @@
-<dataset>
-
-  <groups id="100"
-          name="sonar-administrators"
-          description="System administrators"
-          organization_uuid="org1"/>
-  <groups id="101"
-          name="sonar-users"
-          description="Any new users created will automatically join this group"
-          organization_uuid="org1"/>
-  <groups id="102"
-          name="sonar-reviewers"
-          description="Reviewers"
-          organization_uuid="org1"/>
-  <groups id="103"
-          name="sonar-nobody"
-          description="Nobody in this group"
-          organization_uuid="org1"/>
-
-  <!-- user 200 is in all groups -->
-  <groups_users user_id="200"
-                group_id="100"/>
-  <groups_users user_id="200"
-                group_id="101"/>
-  <groups_users user_id="200"
-                group_id="102"/>
-
-  <!-- user 201 is in users group -->
-  <groups_users user_id="201"
-                group_id="101"/>
-
-  <users id="200"
-         login="admin login"
-         name="Admin name"
-         email="admin@email.com"
-         active="[true]"
-         is_root="[false]"/>
-  <users id="201"
-         login="not.admin"
-         name="Not Admin"
-         email="not admin"
-         active="[true]"
-         is_root="[false]"/>
-  <users id="202"
-         login="inactive"
-         name="Inactive"
-         active="[false]"
-         is_root="[false]"/>
-
-</dataset>

diff --git a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/should_be_sorted_by_group_name.xml b/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/should_be_sorted_by_group_name.xml
deleted file mode 100644 (file)
index 2dfe5ea..0000000
--- a/server/sonar-db-dao/src/test/resources/org/sonar/db/user/GroupMembershipDaoTest/should_be_sorted_by_group_name.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<dataset>
-
-  <groups id="100"
-          name="sonar-users"
-          description="Any new users created will automatically join this group"
-          organization_uuid="org1"/>
-  <groups id="101"
-          name="sonar-administrators"
-          description="System administrators"
-          organization_uuid="org1"/>
-  <groups id="102"
-          name="sonar-reviewers"
-          description="Reviewers"
-          organization_uuid="org1"/>
-
-  <!-- user 200 is in all groups -->
-  <groups_users user_id="200"
-                group_id="100"/>
-  <groups_users user_id="200"
-                group_id="101"/>
-  <groups_users user_id="200"
-                group_id="102"/>
-
-</dataset>