1   package com.atlassian.user.generic;
2   
3   import com.atlassian.user.*;
4   import com.atlassian.user.impl.DefaultGroup;
5   import com.atlassian.user.impl.DuplicateEntityException;
6   import com.atlassian.user.search.page.Pager;
7   import com.atlassian.user.search.page.PagerUtils;
8   import net.sf.hibernate.HibernateException;
9   
10  import java.util.Iterator;
11  import java.util.List;
12  
13  /**
14   * Extend this class and implement the {@link #getUserManager} and {@link #getGroupManager} methods
15   * to run these test over other implementions.
16   */
17  public abstract class AbstractTestGroupManager extends AbstractSpringTest
18  {
19      /**
20       * Override to return a specific implementation for testing
21       */
22      protected abstract GroupManager getGroupManager();
23  
24      /**
25       * Override to return a specific implementation for testing
26       */
27      protected abstract UserManager getUserManager();
28  
29      public final void testGetGroup() throws EntityException
30      {
31          GroupManager groupManager = getGroupManager();
32          Group group = groupManager.createGroup("cool-group");
33          assertEquals(group, groupManager.getGroup("cool-group"));
34          groupManager.removeGroup(group);
35          assertNull(groupManager.getGroup("cool-group"));
36      }
37  
38      public final void testGetGroups() throws EntityException
39      {
40          GroupManager groupManager = getGroupManager();
41          // account for repositories which have existing groups and users at the start
42          int groupsAtStart = PagerUtils.count(groupManager.getGroups());
43  
44          Group group = groupManager.createGroup("group1");
45          groupManager.createGroup("group2");
46          groupManager.createGroup("group3");
47          groupManager.createGroup("group4");
48          assertEquals("check newly created groups are returned",
49              4, PagerUtils.count(groupManager.getGroups()) - groupsAtStart);
50  
51          groupManager.removeGroup(group);
52          assertEquals(3, PagerUtils.count(groupManager.getGroups()) - groupsAtStart);
53  
54          groupManager.createGroup("group5");
55          assertEquals(4, PagerUtils.count(groupManager.getGroups()) - groupsAtStart);
56      }
57  
58      public final void testGetGroupsWithNullUser() throws Exception
59      {
60          try
61          {
62              getGroupManager().getGroups(null);
63              fail("Expected IllegalArgumentException for null user");
64          }
65          catch (IllegalArgumentException expected)
66          {
67          }
68      }
69  
70      public final void testGetWritableGroups() throws EntityException
71      {
72          GroupManager groupManager = getGroupManager();
73          // account for repositories which have existing groups and users at the start
74          int writableGroupsAtStart = groupManager.getWritableGroups().size();
75  
76          groupManager.createGroup("group1");
77          groupManager.createGroup("group2");
78          groupManager.createGroup("group3");
79          
80          if (groupManager.isCreative())
81          {
82              assertEquals("newly created groups should be writable",
83                  3, groupManager.getWritableGroups().size() - writableGroupsAtStart);
84          }
85          else
86          {
87              assertTrue(groupManager.getWritableGroups().isEmpty());
88          }
89      }
90  
91      public final void testAddMembership() throws EntityException
92      {
93          Group group = getGroupManager().createGroup("group");
94          User user = getUserManager().createUser("user");
95  
96          getGroupManager().addMembership(group, user);
97          assertTrue(getGroupManager().hasMembership(group, user));
98  
99          List groupsForUser = PagerUtils.toList(getGroupManager().getGroups(user));
100         assertEquals(1, groupsForUser.size());
101         assertEquals(group, groupsForUser.get(0));
102 
103         List userNamesForGroup = PagerUtils.toList(getGroupManager().getMemberNames(group));
104         assertEquals(1, userNamesForGroup.size());
105         assertEquals(user.getName(), userNamesForGroup.get(0));
106     }
107 
108     public final void testMembershipWithInvalidGroup() throws EntityException
109     {
110         Group group = new DefaultGroup("group"); // group not added to group manager
111         User user = getUserManager().createUser("user");
112 
113         try
114         {
115             getGroupManager().addMembership(group, user);
116             fail("Expected IllegalArgumentException");
117         }
118         catch (IllegalArgumentException e)
119         {
120             // expected exception
121         }
122 
123         assertFalse(getGroupManager().hasMembership(group, user));
124 
125         try
126         {
127             getGroupManager().removeMembership(group, user);
128             fail("Expected IllegalArgumentException");
129         }
130         catch (IllegalArgumentException e)
131         {
132             // expected exception
133         }
134     }
135 
136     public final void testMembershipWithNullGroup() throws EntityException
137     {
138         User user = getUserManager().createUser("user");
139 
140         try
141         {
142             getGroupManager().addMembership(null, user);
143             fail("Expected IllegalArgumentException");
144         }
145         catch (IllegalArgumentException e)
146         {
147             // expected exception
148         }
149 
150         assertFalse(getGroupManager().hasMembership(null, user));
151 
152         try
153         {
154             getGroupManager().removeMembership(null, user);
155             fail("Expected IllegalArgumentException");
156         }
157         catch (IllegalArgumentException e)
158         {
159             // expected exception
160         }
161     }
162 
163     public final void testRemoveGroupWithMembership() throws EntityException
164     {
165         GroupManager groupManager = getGroupManager();
166         UserManager userManager = getUserManager();
167 
168         Group group = groupManager.createGroup("group");
169         User user = userManager.createUser("user");
170         groupManager.addMembership(group, user);
171         assertTrue(groupManager.hasMembership(group, user));
172         try
173         {
174             groupManager.removeGroup(group);
175         }
176         catch (EntityException e)
177         {
178             fail("unable to remove group with membership: " + e);
179         }
180         try
181         {
182             assertFalse(groupManager.hasMembership(group, user));
183         }
184         catch (IllegalArgumentException e)
185         {
186             // the hibernate implementation throws this exception if the group doesn't exist
187         }
188         assertNull(groupManager.getGroup("group"));
189     }
190 
191     public final void testRemoveMembership() throws EntityException
192     {
193         GroupManager groupManager = getGroupManager();
194         UserManager userManager = getUserManager();
195 
196         Group group = groupManager.createGroup("group");
197         User user = userManager.createUser("user");
198         groupManager.addMembership(group, user);
199         assertTrue(groupManager.hasMembership(group, user));
200         groupManager.removeMembership(group, user);
201 
202         assertFalse(groupManager.hasMembership(group, user));
203         List groupsForUser = PagerUtils.toList(groupManager.getGroups(user));
204         assertEquals(0, groupsForUser.size());
205 
206         List usersForGroup = PagerUtils.toList(groupManager.getMemberNames(group));
207         assertEquals(0, usersForGroup.size());
208 
209     }
210 
211 
212     public void testCreateGroup() throws EntityException, HibernateException
213     {
214         Group group = getGroupManager().createGroup("group");
215         assertNotNull(group);
216 
217         try
218         {
219             getGroupManager().createGroup("group");
220             fail("Expected DuplicateEntityException when trying to create a duplicate group");
221         }
222         catch (DuplicateEntityException expected)
223         {
224         }
225 
226         assertEquals(1, PagerUtils.count(getGroupManager().getGroups()));
227     }
228 
229     public void testAddMembershipLocal() throws Exception
230     {
231         Group group = getGroupManager().createGroup("group");
232         User user = getUserManager().createUser("user");
233 
234         getGroupManager().addMembership(group, user);
235 
236         assertTrue(getGroupManager().hasMembership(group, user));
237     }
238 
239 
240     public void testRemoveLocalMembership() throws EntityException, HibernateException
241     {
242         Group group = getGroupManager().createGroup("group");
243         User user = getUserManager().createUser("user");
244         getGroupManager().addMembership(group, user);
245 
246         getGroupManager().removeMembership(group, user);
247         assertFalse(getGroupManager().hasMembership(group, user));
248     }
249 
250     public void testRemoveGroup() throws EntityException
251     {
252         Group group = getGroupManager().createGroup("test");
253         getGroupManager().removeGroup(group);
254 
255         User user = getUserManager().createUser("fred");
256         group = getGroupManager().createGroup("test");
257         getGroupManager().addMembership(group, user);
258 
259         assertTrue(getGroupManager().hasMembership(group, user));
260         getGroupManager().removeGroup(group);
261         assertFalse(getGroupManager().hasMembership(group, user));
262     }
263 
264     public void testGetLocalMemberNames() throws EntityException
265     {
266         Group group = getGroupManager().createGroup("group");
267         User user = getUserManager().createUser("user");
268         getGroupManager().addMembership(group, user);
269         Pager pager = getGroupManager().getMemberNames(group);
270 
271         assertEquals(1, PagerUtils.count(pager));
272     }
273 
274     public void testGetLocalMembers() throws EntityException
275     {
276         Group group = getGroupManager().createGroup("group");
277         User user = getUserManager().createUser("user");
278         getGroupManager().addMembership(group, user);
279         Pager pager = getGroupManager().getLocalMemberNames(group);
280 
281         assertEquals(1, pager.getCurrentPage().size());
282     }
283 
284     public void testGetLocalMembersOrderedByUserName() throws EntityException
285     {
286         Group group = getGroupManager().createGroup("group");
287         User user1 = getUserManager().createUser("user-a");
288         User user2 = getUserManager().createUser("user-b");
289         getGroupManager().addMembership(group, user2); // add membership in reverse order
290         getGroupManager().addMembership(group, user1);
291         Pager pager = getGroupManager().getLocalMemberNames(group);
292 
293         assertEquals(2, pager.getCurrentPage().size());
294         assertEquals("user-a", pager.getCurrentPage().get(0));
295         assertEquals("user-b", pager.getCurrentPage().get(1));
296     }
297 
298     public void testGetMemberNames() throws EntityException
299     {
300         Group group = getGroupManager().createGroup("group");
301         User user1 = getUserManager().createUser("user-a");
302         User user2 = getUserManager().createUser("user-b");
303         getGroupManager().addMembership(group, user2); // add membership in reverse order
304         getGroupManager().addMembership(group, user1);
305         Pager pager = getGroupManager().getMemberNames(group);
306 
307         assertEquals(2, pager.getCurrentPage().size());
308         assertEquals("user-a", pager.getCurrentPage().get(0));
309         assertEquals("user-b", pager.getCurrentPage().get(1));
310     }
311 
312     public void testGetGroupsForUser() throws EntityException
313     {
314         Group group = getGroupManager().createGroup("group");
315         User user = getUserManager().createUser("user");
316         getGroupManager().addMembership(group, user);
317         Pager pager = getGroupManager().getGroups(user);
318 
319         Iterator iter = pager.iterator();
320         Group discoveredGroup = null;
321 
322         while (iter.hasNext())
323         {
324             discoveredGroup = (Group) iter.next();
325 
326             if (discoveredGroup != null)
327                 break;
328         }
329 
330         assertEquals(group, discoveredGroup);
331     }
332 
333     public final void testRemoveUserRemovesMemberships() throws EntityException
334     {
335         UserManager userManager = getUserManager();
336         GroupManager groupManager = getGroupManager();
337 
338         User user = userManager.createUser("user");
339         Group group = groupManager.createGroup("group");
340         groupManager.addMembership(group, user);
341         userManager.removeUser(user);
342 
343         assertNull("User should have been removed", userManager.getUser("user"));
344         assertEquals(group, groupManager.getGroup("group"));
345         assertTrue("Should be no members in group", groupManager.getMemberNames(group).isEmpty());
346         assertTrue("Non-existent user should have no groups", groupManager.getGroups(user).isEmpty());
347     }
348 
349     public void testEqualityOnGroup() throws EntityException
350     {
351         GroupManager groupManager = getGroupManager();
352         Group title = groupManager.createGroup("title");
353         Group title2 = groupManager.createGroup("title2");
354 
355         Group titleDup = groupManager.getGroup("title");
356 
357         assertFalse("equality in DefaultGroup is incorrect", title2.equals(titleDup));
358         assertEquals(title, titleDup);
359     }
360 
361     public void testHashingOnGroup() throws EntityException
362     {
363         GroupManager groupManager = getGroupManager();
364 
365         int hash1 = groupManager.createGroup("titlegroup").hashCode();
366         int hash2 = groupManager.getGroup("titlegroup").hashCode();
367         int hash3 = groupManager.createGroup("title2group").hashCode();
368 
369         assertEquals("Group object's hashcode is incorrect", hash1, hash2);
370         assertFalse("Group object's hashcode is incorrect", hash2 == hash3);
371      }
372 }