1 package com.atlassian.user.generic;
2
3 import com.atlassian.user.*;
4 import com.atlassian.user.repository.RepositoryIdentifier;
5 import com.atlassian.user.search.SearchResult;
6 import com.atlassian.user.search.page.Pager;
7 import com.atlassian.user.search.page.PagerUtils;
8 import com.atlassian.user.search.query.*;
9
10 import java.util.ArrayList;
11 import java.util.Iterator;
12 import java.util.List;
13
14
15
16
17
18 public abstract class AbstractEntityQueryParserTest extends AbstractSpringTest
19 {
20
21
22
23 protected abstract GroupManager getGroupManager();
24
25
26
27
28 protected abstract UserManager getUserManager();
29
30
31
32
33 protected abstract EntityQueryParser getEntityQueryParser();
34
35
36
37
38 protected abstract RepositoryIdentifier getRepositoryIdentifier();
39
40 public final void testUserNameTermQuery() throws EntityException
41 {
42 UserManager userManager = getUserManager();
43 EntityQueryParser entityParser = getEntityQueryParser();
44
45 User source = userManager.createUser("fred");
46 userManager.createUser("susan");
47
48 UserNameTermQuery query = new UserNameTermQuery("fred");
49
50 SearchResult result = entityParser.findUsers(query);
51 Iterator iter = result.pager().iterator();
52
53 User foundUser = null;
54
55 while (iter.hasNext())
56 {
57 foundUser = (User) iter.next();
58 if (foundUser != null)
59 break;
60 }
61
62 assertEquals(source, foundUser);
63
64 query = new UserNameTermQuery("fr", TermQuery.SUBSTRING_STARTS_WITH);
65
66 result = entityParser.findUsers(query);
67 iter = result.pager().iterator();
68
69 foundUser = null;
70
71 while (iter.hasNext())
72 {
73 foundUser = (User) iter.next();
74 if (foundUser != null)
75 break;
76 }
77
78 assertEquals(source, foundUser);
79 }
80
81 public final void testGroupNameTermQuery() throws Exception
82 {
83 GroupManager groupManager = getGroupManager();
84 EntityQueryParser entityParser = getEntityQueryParser();
85
86 Group group = groupManager.createGroup("aaaa");
87 groupManager.createGroup("aaab");
88 Group group2 = groupManager.createGroup("aaac");
89
90 GroupNameTermQuery query = new GroupNameTermQuery("aaaa");
91 SearchResult result = entityParser.findGroups(query);
92
93 Pager pager = result.pager();
94 Iterator iter = pager.iterator();
95 Group foundGroup = null;
96
97 if (iter.hasNext())
98 {
99 foundGroup = (Group) iter.next();
100 }
101
102 assertEquals(group, foundGroup);
103
104 query = new GroupNameTermQuery("aaa", TermQuery.SUBSTRING_STARTS_WITH);
105 result = entityParser.findGroups(query);
106 pager = result.pager();
107
108 assertEquals(3, PagerUtils.count(pager));
109
110 query = new GroupNameTermQuery("c", TermQuery.SUBSTRING_ENDS_WITH);
111 result = entityParser.findGroups(query);
112 pager = result.pager();
113
114 List found = PagerUtils.toList(pager);
115
116 assertEquals(1, found.size());
117
118 iter = found.iterator();
119
120 if (iter.hasNext())
121 {
122 foundGroup = (Group) iter.next();
123 }
124
125 assertEquals(group2, foundGroup);
126 }
127
128 public final void testFullNameTermQuery() throws Exception
129 {
130 UserManager userManager = getUserManager();
131 GroupManager groupManager = getGroupManager();
132 EntityQueryParser entityParser = getEntityQueryParser();
133
134 User user = userManager.createUser("fred");
135 user.setFullName("fred smithers");
136 userManager.saveUser(user);
137 User user1 = userManager.createUser("mary");
138 user1.setFullName("mary unpopthis");
139 userManager.saveUser(user1);
140 User user2 = userManager.createUser("peter");
141 user2.setFullName("peter puker");
142 userManager.saveUser(user2);
143 User user3 = userManager.createUser("chronos");
144 user3.setFullName("Chronos iatealotofgods");
145 userManager.saveUser(user3);
146 Group group = groupManager.createGroup("g1");
147 Group group1 = groupManager.createGroup("g2");
148
149 groupManager.addMembership(group, user);
150 groupManager.addMembership(group, user1);
151 groupManager.addMembership(group, user2);
152 groupManager.addMembership(group1, user2);
153 groupManager.addMembership(group1, user3);
154
155 FullNameTermQuery query = new FullNameTermQuery("iatealotofgods", TermQuery.SUBSTRING_ENDS_WITH);
156 SearchResult result = entityParser.findUsers(query);
157 Pager pager = result.pager();
158
159 assertEquals(1, pager.getCurrentPage().size());
160 assertEquals(user3, pager.getCurrentPage().get(0));
161
162 query = new FullNameTermQuery("C", TermQuery.SUBSTRING_STARTS_WITH);
163 result = entityParser.findUsers(query);
164
165 pager = result.pager();
166
167 assertEquals(1, pager.getCurrentPage().size());
168 assertEquals(user3, pager.getCurrentPage().get(0));
169
170 query = new FullNameTermQuery("puk", TermQuery.SUBSTRING_CONTAINS);
171
172 result = entityParser.findUsers(query);
173
174 pager = result.pager();
175
176 assertEquals(1, pager.getCurrentPage().size());
177 assertEquals(user2, pager.getCurrentPage().get(0));
178 }
179
180 public void testNoMatchingUserQueryContextNoSearch() throws EntityException
181 {
182 getUserManager().createUser("astroboy");
183 getUserManager().createUser("atlas");
184 QueryContext context = new DefaultQueryContext();
185 context.addRepositoryKey("dontrun");
186
187 UserNameTermQuery query = new UserNameTermQuery("astro", TermQuery.SUBSTRING_CONTAINS);
188
189 SearchResult searchResults = getEntityQueryParser().findUsers(query, context);
190 assertNull(this.getClass().getName() + " is processing queries which are not meant for its repository",
191 searchResults);
192
193 context = new DefaultQueryContext();
194 context.addRepositoryKey(QueryContext.ALL_REPOSITORIES);
195
196 searchResults = getEntityQueryParser().findUsers(query, context);
197 assertNotNull(this.getClass().getName() + " is ignoring universal queries", searchResults);
198 }
199
200 public void testNoMatchingGroupQueryContextNoSearch() throws EntityException
201 {
202 getGroupManager().createGroup("group");
203 QueryContext context = new DefaultQueryContext();
204 context.addRepositoryKey("dontrun");
205
206 GroupNameTermQuery query = new GroupNameTermQuery("group", TermQuery.SUBSTRING_CONTAINS);
207
208 SearchResult searchResults = getEntityQueryParser().findGroups(query, context);
209 assertNull(this.getClass().getName() + " is processing queries which are not meant for its repository",
210 searchResults);
211
212 context = new DefaultQueryContext();
213 context.addRepositoryKey(QueryContext.ALL_REPOSITORIES);
214
215 searchResults = getEntityQueryParser().findGroups(query, context);
216 assertNotNull(this.getClass().getName() + " is ignoring universal queries", searchResults);
217 }
218
219 public void testNestedBooleanAndQuery() throws Exception
220 {
221 createTestUsers();
222
223 TermQuery q1 = new UserNameTermQuery("r", TermQuery.SUBSTRING_CONTAINS);
224 TermQuery q2 = new EmailTermQuery("org", TermQuery.SUBSTRING_CONTAINS);
225
226 TermQuery q3 = new UserNameTermQuery("bob", TermQuery.SUBSTRING_CONTAINS);
227 TermQuery q4 = new EmailTermQuery("acme", TermQuery.SUBSTRING_CONTAINS);
228
229 List queries = new ArrayList();
230 queries.add(q1);
231 queries.add(q2);
232 BooleanQuery query = new TwoTermBooleanQuery(q3, q4, BooleanQuery.AND);
233 queries.add(query);
234 MultiTermBooleanQuery parentQuery = new MultiTermBooleanQuery((Query[]) queries.toArray(new Query[1]), true);
235
236 SearchResult result = getEntityQueryParser().findUsers(parentQuery);
237 Pager pager = result.pager();
238
239 assertEquals(0, pager.getCurrentPage().size());
240 }
241
242 public void testSearchGroupsWithGroupnameWithSubstring() throws EntityException
243 {
244 createTestGroups();
245 GroupNameTermQuery query = new GroupNameTermQuery("sceptics");
246
247 QueryContext queryContext = new DefaultQueryContext();
248 queryContext.addRepositoryKey(getRepositoryIdentifier().getKey());
249
250 List results = PagerUtils.toList(getEntityQueryParser().findGroups(query, queryContext).pager());
251 assertEquals("MemoryEntityQueryParser is not returning correct results from a group query",
252 1, results.size());
253
254 GroupNameTermQuery query2 = new GroupNameTermQuery("ists", TermQuery.SUBSTRING_ENDS_WITH);
255
256 List results2 = PagerUtils.toList(getEntityQueryParser().findGroups(query2, queryContext).pager());
257 assertEquals("MemoryEntityQueryParser is not returning correct results from a group query",
258 3, results2.size());
259
260 GroupNameTermQuery query3 = new GroupNameTermQuery("s", TermQuery.SUBSTRING_STARTS_WITH);
261
262 List results3 = PagerUtils.toList(getEntityQueryParser().findGroups(query3, queryContext).pager());
263 assertEquals("MemoryEntityQueryParser is not returning correct results from a group query",
264 2, results3.size());
265
266 GroupNameTermQuery query4 = new GroupNameTermQuery("i", TermQuery.SUBSTRING_CONTAINS);
267
268 List results4 = PagerUtils.toList(getEntityQueryParser().findGroups(query4, queryContext).pager());
269 assertEquals("MemoryEntityQueryParser is not returning correct results from a group query",
270 4, results4.size());
271 }
272
273 private void createTestGroups() throws EntityException
274 {
275 getGroupManager().createGroup("solipsists");
276 getGroupManager().createGroup("nihilists");
277 getGroupManager().createGroup("marxists");
278 getGroupManager().createGroup("sceptics");
279 }
280
281 protected void createTestUsers() throws EntityException
282 {
283 User user1 = getUserManager().createUser("icarus");
284 user1.setEmail("icarus@test.org");
285 User user2 = getUserManager().createUser("orpheus");
286 user2.setEmail("orpheus@test.org");
287 User user3 = getUserManager().createUser("bob");
288 user3.setEmail("bob@acme.org");
289 User user4 = getUserManager().createUser("peter");
290 user4.setEmail("peter@acme.org");
291
292 getUserManager().saveUser(user1);
293 getUserManager().saveUser(user2);
294 getUserManager().saveUser(user3);
295 getUserManager().saveUser(user4);
296 }
297
298 public void testSearchUserWithFullnameWithSubstring() throws EntityException
299 {
300 createTestUsers();
301 User potter = getUserManager().createUser("1");
302 potter.setFullName("harry potter");
303 User drum = getUserManager().createUser("2");
304 drum.setFullName("aiken drum");
305 getUserManager().saveUser(potter);
306 getUserManager().saveUser(potter);
307
308 QueryContext queryContext = new DefaultQueryContext();
309 queryContext.addRepositoryKey(getRepositoryIdentifier().getKey());
310
311 FullNameTermQuery query = new FullNameTermQuery("aiken", TermQuery.SUBSTRING_CONTAINS);
312 Pager pager = getEntityQueryParser().findUsers(query, queryContext).pager();
313
314 List list = PagerUtils.toList(pager);
315 assertEquals(1, list.size(), 1);
316 User u = (User) list.get(0);
317 assertEquals(drum, u);
318 }
319
320 public void testBooleanUserNameTermQuery() throws Exception
321 {
322 createTestUsers();
323
324 TermQuery q1 = new UserNameTermQuery("r", TermQuery.SUBSTRING_CONTAINS);
325 TermQuery q2 = new EmailTermQuery("org", TermQuery.SUBSTRING_CONTAINS);
326
327 BooleanQuery query = new TwoTermBooleanQuery(q1, q2, BooleanQuery.AND);
328
329 SearchResult result = getEntityQueryParser().findUsers(query);
330 Pager pager = result.pager();
331
332 assertEquals(3, pager.getCurrentPage().size());
333 assertTrue("result should include icarus", pagerContainsUsername(pager, "icarus"));
334 assertTrue("result should include orpheus", pagerContainsUsername(pager, "orpheus"));
335 assertTrue("result should include peter", pagerContainsUsername(pager, "peter"));
336 }
337
338 protected boolean pagerContainsUsername(Pager pager, String username)
339 {
340 for (Iterator i = pager.getCurrentPage().iterator(); i.hasNext();)
341 {
342 User user = (User) i.next();
343 if (user.getName().equals(username))
344 {
345 return true;
346 }
347 }
348 return false;
349 }
350
351 public void testSearchUserWithUsernameWithSubstring() throws EntityException
352 {
353 QueryContext queryContext = new DefaultQueryContext();
354 queryContext.addRepositoryKey(getRepositoryIdentifier().getKey());
355
356 UserNameTermQuery query = new UserNameTermQuery("bob");
357 createTestUsers();
358 User bob = getUserManager().getUser("bob");
359
360 Pager pager = getEntityQueryParser().findUsers(query, queryContext).pager();
361 List list = PagerUtils.toList(pager);
362
363 assertEquals(1, list.size());
364 User u = (User) list.get(0);
365 assertEquals(bob, u);
366
367 User rob = getUserManager().createUser("rob");
368 getUserManager().saveUser(rob);
369
370 UserNameTermQuery query2 = new UserNameTermQuery("ob", TermQuery.SUBSTRING_ENDS_WITH);
371 Pager pager2 = getEntityQueryParser().findUsers(query2, queryContext).pager();
372
373 List list2 = PagerUtils.toList(pager2);
374 assertEquals(2, list2.size());
375
376
377 assertTrue(list2.contains(rob));
378 assertTrue(list2.contains(bob));
379
380
381
382
383 }
384
385 public void testORUserNameTermQuery() throws EntityException
386 {
387 QueryContext queryContext = new DefaultQueryContext();
388 queryContext.addRepositoryKey(getRepositoryIdentifier().getKey());
389
390 createTestUsers();
391 UserNameTermQuery query = new UserNameTermQuery("bob");
392 UserNameTermQuery query2 = new UserNameTermQuery("icarus");
393
394 TwoTermBooleanQuery bQuery = new TwoTermBooleanQuery(query2, query, false);
395
396 Pager pager = getEntityQueryParser().findUsers(bQuery, queryContext).pager();
397 List results = pager.getCurrentPage();
398
399 assertEquals(2, results.size());
400 }
401
402 }