1 package com.atlassian.user.impl.delegation;
2
3 import com.atlassian.user.EntityException;
4 import com.atlassian.user.Group;
5 import com.atlassian.user.GroupManager;
6 import com.atlassian.user.User;
7 import com.atlassian.user.impl.DefaultGroup;
8 import com.atlassian.user.impl.DefaultUser;
9 import com.atlassian.user.impl.ldap.repository.LdapConnectionFailedException;
10 import com.atlassian.user.repository.DefaultRepositoryIdentifier;
11 import com.atlassian.user.repository.RepositoryIdentifier;
12 import com.atlassian.user.search.page.DefaultPager;
13 import com.atlassian.user.search.page.Pager;
14 import com.atlassian.user.search.page.PagerFactory;
15 import com.atlassian.user.search.page.PagerUtils;
16 import com.mockobjects.dynamic.C;
17 import com.mockobjects.dynamic.Mock;
18 import junit.framework.TestCase;
19 import org.apache.commons.collections.ListUtils;
20
21 import java.util.ArrayList;
22 import java.util.Arrays;
23 import java.util.List;
24
25 public class TestDelegatingGroupManager extends TestCase
26 {
27 private DelegatingGroupManager delegatingGroupManager;
28 private Mock mockCreatingGroupManager;
29 private Mock mockOtherGroupManager;
30
31 public void setUp() throws Exception
32 {
33 super.setUp();
34 mockCreatingGroupManager = new Mock(GroupManager.class);
35 mockOtherGroupManager = new Mock(GroupManager.class);
36 delegatingGroupManager = new DelegatingGroupManager(Arrays.asList(
37 (GroupManager) mockCreatingGroupManager.proxy(),
38 (GroupManager) mockOtherGroupManager.proxy()));
39 }
40
41 public void testGetGroupUsingMocks() throws EntityException
42 {
43 DefaultGroup group = new DefaultGroup("testGroup");
44
45 mockCreatingGroupManager.expectAndReturn("getGroup", C.args(C.eq("testGroup")), null);
46 mockOtherGroupManager.expectAndReturn("getGroup", C.args(C.eq("testGroup")), group);
47
48 assertEquals("delegatingGroupManager is not getting groups correctly",
49 delegatingGroupManager.getGroup("testGroup"), group);
50
51 mockCreatingGroupManager.verify();
52 mockOtherGroupManager.verify();
53 }
54
55 public void testGetGroupsUsingMocks() throws EntityException
56 {
57 List<DefaultGroup> groupList1 = new ArrayList<DefaultGroup>();
58 for (int i=1; i<=3; i++)
59 groupList1.add(new DefaultGroup("group" + i));
60 List<DefaultGroup> groupList2 = new ArrayList<DefaultGroup>();
61 for (int i=4; i<=6; i++)
62 groupList1.add(new DefaultGroup("group" + i));
63
64 Pager<DefaultGroup> iter1 = new DefaultPager<DefaultGroup>(groupList1);
65 Pager<DefaultGroup> iter2 = new DefaultPager<DefaultGroup>(groupList2);
66
67 Pager<DefaultGroup> iter3 = PagerFactory.getPager(iter1, iter2);
68
69 mockCreatingGroupManager.expectAndReturn("getGroups", new DefaultPager<DefaultGroup>(groupList1));
70 mockOtherGroupManager.expectAndReturn("getGroups", new DefaultPager<DefaultGroup>(groupList2));
71
72 assertPagingIteratorsEqual("delegatingGroupManager getGroups is not merging results correctly", iter3,
73 delegatingGroupManager.getGroups());
74 }
75
76 public void testGetGroupsWhenFirstThrowsException() throws Exception
77 {
78 List<Group> groups = new ArrayList<Group>();
79 for (int i=1; i<=3; i++)
80 groups.add(new DefaultGroup("group" + i));
81
82 Pager<Group> iter1 = new DefaultPager<Group>(groups);
83
84 mockCreatingGroupManager.expectAndThrow("getGroups", new LdapConnectionFailedException());
85 mockOtherGroupManager.expectAndReturn("getGroups", new DefaultPager<Group>(groups));
86
87 assertPagingIteratorsEqual("delegatingGroupManager getGroups is not merging results correctly", iter1,
88 delegatingGroupManager.getGroups());
89 }
90
91 public void testGetGroupsForUserWhenFirstThrowsException() throws Exception
92 {
93 List<Group> groups = new ArrayList<Group>();
94 for (int i=1; i<=3; i++)
95 groups.add(new DefaultGroup("group" + i));
96
97 Pager<Group> iter1 = new DefaultPager<Group>(groups);
98
99 mockCreatingGroupManager.expectAndThrow("getGroups", new DefaultUser(), new LdapConnectionFailedException());
100 mockOtherGroupManager.expectAndReturn("getGroups", new DefaultUser(), new DefaultPager<Group>(groups));
101
102 assertPagingIteratorsEqual("delegatingGroupManager getGroups is not merging results correctly", iter1,
103 delegatingGroupManager.getGroups(new DefaultUser()));
104 }
105
106 public void testGetWritableGroupsUsingMocks() throws EntityException
107 {
108 List<DefaultGroup> groupList1 = new ArrayList<DefaultGroup>();
109 List<DefaultGroup> groupList2 = new ArrayList<DefaultGroup>();
110
111 groupList1.add(new DefaultGroup("group1"));
112 groupList1.add(new DefaultGroup("group2"));
113 groupList1.add(new DefaultGroup("group3"));
114
115 groupList2.add(new DefaultGroup("group4"));
116
117 mockCreatingGroupManager.expectAndReturn("getWritableGroups", groupList1);
118 mockOtherGroupManager.expectAndReturn("getWritableGroups", groupList2);
119
120 assertEquals(ListUtils.sum(groupList1, groupList2),delegatingGroupManager.getWritableGroups());
121 }
122
123 public void testGetWritableGroupsWhenOneThrowsException() throws Exception
124 {
125 List<DefaultGroup> groups = new ArrayList<DefaultGroup>();
126 for (int i=1; i<=3; i++)
127 groups.add(new DefaultGroup("group" + i));
128
129 mockCreatingGroupManager.expectAndReturn("getWritableGroups", new DefaultPager<DefaultGroup>(groups));
130 mockOtherGroupManager.expectAndThrow("getWritableGroups", new RuntimeException());
131
132 try
133 {
134 delegatingGroupManager.getWritableGroups();
135 fail("Runtime exception expected");
136 }
137 catch (RuntimeException expected)
138 {
139 }
140 }
141
142
143 private static <T> void assertPagingIteratorsEqual(String message, Pager<? extends T> iterator1, Pager<? extends T> iterator2)
144 {
145 List<? extends T> list1 = PagerUtils.toList(iterator1);
146 List<? extends T> list2 = PagerUtils.toList(iterator2);
147
148 assertEquals(message, list1, list2);
149 }
150
151 public void testGetGroupsForUser() throws EntityException
152 {
153 List<Group> groupList2 = new ArrayList<Group>();
154
155 groupList2.add(new DefaultGroup("group4"));
156 groupList2.add(new DefaultGroup("group5"));
157 groupList2.add(new DefaultGroup("group6"));
158
159 Pager<Group> iter2 = new DefaultPager<Group>(groupList2);
160
161 User user = new DefaultUser("testUser");
162
163 mockCreatingGroupManager.expectAndReturn("getGroups", C.args(C.eq(user)), null);
164 mockOtherGroupManager.expectAndReturn("getGroups", C.args(C.eq(user)), new DefaultPager<Group>(groupList2));
165
166 assertPagingIteratorsEqual("delegatingGroupManager getGroups(user) is not merging results correctly", iter2,
167 delegatingGroupManager.getGroups(user));
168 }
169
170
171 public void testCreateGroup() throws EntityException
172 {
173 Group group = new DefaultGroup("test");
174 mockCreatingGroupManager.matchAndReturn("getGroup", C.args(C.eq("test")), null);
175 mockOtherGroupManager.matchAndReturn("getGroup", C.args(C.eq("test")), null);
176 mockCreatingGroupManager.expectAndReturn("isCreative", true);
177 mockCreatingGroupManager.expectAndReturn("createGroup", C.args(C.eq("test")), group);
178
179 Group createdGroup = delegatingGroupManager.createGroup("test");
180 assertEquals("delegatingGroupManager is not creating groups via the creatingGroupManager",
181 group, createdGroup);
182
183 mockCreatingGroupManager.verify();
184 mockOtherGroupManager.verify();
185 }
186
187 public void testRemoveGroupUsingMocks()
188 {
189 Group group = new DefaultGroup("test");
190 mockCreatingGroupManager.expectAndReturn("getGroup", "test", null);
191 mockOtherGroupManager.expectAndReturn("getGroup", "test", group);
192 mockOtherGroupManager.expectAndReturn("isReadOnly", group, false);
193 mockOtherGroupManager.expect("removeGroup", group);
194
195 try
196 {
197 delegatingGroupManager.removeGroup(group);
198 }
199 catch (EntityException e)
200 {
201 fail("delegatingManager is not delegating removals correctly");
202 }
203
204 mockCreatingGroupManager.verify();
205 mockOtherGroupManager.verify();
206 }
207
208 public void testAddMembershipUsingMocks() throws EntityException
209 {
210 Group group = new DefaultGroup("test");
211 User user = new DefaultUser("testUser");
212
213 mockCreatingGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), null);
214 mockOtherGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), group);
215 mockOtherGroupManager.expect("addMembership", C.args(C.eq(group), C.eq(user)));
216
217 delegatingGroupManager.addMembership(group, user);
218
219 mockCreatingGroupManager.verify();
220 mockOtherGroupManager.verify();
221 }
222
223 public void testHasMembership() throws EntityException
224 {
225 Group group = new DefaultGroup("test");
226 User user = new DefaultUser("testUser");
227
228 mockCreatingGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), null);
229 mockOtherGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), group);
230 mockOtherGroupManager.expectAndReturn("hasMembership", C.args(C.eq(group), C.eq(user)), true);
231
232 assertTrue(delegatingGroupManager.hasMembership(group, user));
233
234 mockCreatingGroupManager.verify();
235 mockOtherGroupManager.verify();
236 }
237
238 public void testRemoveMembershipUsingMocks() throws EntityException
239 {
240 Group group = new DefaultGroup("test");
241 User user = new DefaultUser("testUser");
242
243 mockCreatingGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), null);
244 mockOtherGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), group);
245 mockOtherGroupManager.expect("removeMembership", C.args(C.eq(group), C.eq(user)));
246
247 delegatingGroupManager.removeMembership(group, user);
248
249 mockCreatingGroupManager.verify();
250 mockOtherGroupManager.verify();
251 }
252
253 public void testGetMembers() throws EntityException
254 {
255 Group group = new DefaultGroup("test");
256 ArrayList<DefaultUser> users = new ArrayList<DefaultUser>();
257 users.add(new DefaultUser("testUser1"));
258 users.add(new DefaultUser("testUser2"));
259 users.add(new DefaultUser("testUser3"));
260 users.add(new DefaultUser("testUser4"));
261
262 mockCreatingGroupManager.matchAndReturn("getGroup", C.args(C.eq("test")), null);
263 mockOtherGroupManager.matchAndReturn("getGroup", C.args(C.eq("test")), group);
264 mockOtherGroupManager.matchAndReturn("getMemberNames", C.args(C.eq(group)), new DefaultPager<DefaultUser>(users));
265
266 delegatingGroupManager.getMemberNames(group);
267 }
268
269 public void testGetConfiguration() throws EntityException
270 {
271 Group group = new DefaultGroup("test");
272 RepositoryIdentifier config = new DefaultRepositoryIdentifier("default", "Default repo");
273 mockCreatingGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), null);
274 mockOtherGroupManager.expectAndReturn("getGroup", C.args(C.eq("test")), group);
275 mockOtherGroupManager.expectAndReturn("getIdentifier", config);
276
277 assertEquals("delegatingGroupManager is not delegating getIdentifier(group) call correctly.",
278 config, delegatingGroupManager.getRepository(group));
279
280 mockCreatingGroupManager.verify();
281 mockOtherGroupManager.verify();
282 }
283
284 public void testIsCreating()
285 {
286 mockCreatingGroupManager.expectAndReturn("isCreative", true);
287
288 assertTrue("delegatingUserManager is not calling isReadOnly() on the creatingUserManager when handling this" +
289 "behaviour", delegatingGroupManager.isCreative());
290 }
291 }