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