1 package com.atlassian.user.impl.ldap.search.query;
2
3 import com.atlassian.user.EntityException;
4 import com.atlassian.user.User;
5 import com.atlassian.user.UserManager;
6 import com.atlassian.user.impl.ldap.AbstractLdapTest;
7 import com.atlassian.user.impl.ldap.DefaultLDAPUserFactory;
8 import com.atlassian.user.impl.ldap.adaptor.LDAPGroupAdaptor;
9 import com.atlassian.user.impl.ldap.properties.LdapMembershipProperties;
10 import com.atlassian.user.impl.ldap.properties.LdapSearchProperties;
11 import com.atlassian.user.impl.ldap.repository.LdapContextFactory;
12 import com.atlassian.user.impl.ldap.search.LdapFilterFactory;
13 import com.atlassian.user.repository.RepositoryIdentifier;
14 import com.atlassian.user.search.SearchResult;
15 import com.atlassian.user.search.page.Pager;
16 import com.atlassian.user.search.page.PagerUtils;
17 import com.atlassian.user.search.query.*;
18
19 import java.util.List;
20
21
22
23
24
25 public class TestLDAPEntityQueryParser extends AbstractLdapTest
26 {
27 private static final String USERNAME_1 = "user1";
28 private static final String USERNAME_2 = "user2";
29 private static final String GROUP_NAME_1 = "group1";
30
31 private RepositoryIdentifier ldapIdentifier;
32 private LdapSearchProperties ldapSearchProperties;
33 private LdapMembershipProperties ldapMembershipProperties;
34 private LdapFilterFactory ldapFilterFactory;
35
36 private LdapContextFactory ldapContextFactory;
37 private UserManager ldapUserManager;
38 private LDAPGroupAdaptor ldapGroupAdaptor;
39 private EntityQueryParser queryParser;
40 private QueryContext context;
41
42 protected void onSetUp() throws Exception
43 {
44 super.onSetUp();
45
46 queryParser = new LDAPEntityQueryParser(ldapContextFactory, ldapGroupAdaptor, ldapIdentifier,
47 new DefaultLDAPUserFactory(ldapSearchProperties), ldapSearchProperties,
48 ldapMembershipProperties, ldapFilterFactory);
49
50 context = new DefaultQueryContext(ldapIdentifier);
51 }
52
53
54 protected void onTearDown() throws Exception
55 {
56 context = null;
57 queryParser = null;
58 super.onTearDown();
59 }
60
61 public void testNoMatchingQueryContextNoSearch() throws EntityException
62 {
63 QueryContext otherContext = new DefaultQueryContext("dontrun");
64
65 UserNameTermQuery query = new UserNameTermQuery(USERNAME_1);
66
67 SearchResult searchResults = queryParser.findUsers(query, otherContext);
68 assertNull("ldapEntityQueryParser is processing queries which are not meant for its repository",
69 searchResults);
70
71 searchResults = queryParser.findGroups(query, otherContext);
72 assertNull("ldapEntityQueryParser is processing queries which are not meant for its repository",
73 searchResults);
74
75 searchResults = queryParser.findUsers(query, new AllRepositoriesQueryContext());
76 assertNotNull("ldapEntityQueryParser is ignoring universal queries", searchResults);
77
78 GroupNameTermQuery query2 = new GroupNameTermQuery(GROUP_NAME_1);
79
80 searchResults = queryParser.findUsers(query2, new AllRepositoriesQueryContext());
81 assertNotNull("ldapEntityQueryParser is ignoring universal queries", searchResults);
82 }
83
84 public void testUserNameTermQuery() throws EntityException
85 {
86 UserNameTermQuery query = new UserNameTermQuery("user1");
87
88 Pager pager = queryParser.findUsers(query, context).pager();
89
90 assertEquals(PagerUtils.count(pager), 1);
91 List list = pager.getCurrentPage();
92 User u = (User) list.get(0);
93 User u2 = ldapUserManager.getUser("user1");
94 assertEquals(u2, u);
95
96 UserNameTermQuery query2 = new UserNameTermQuery("user", TermQuery.SUBSTRING_STARTS_WITH);
97
98 Pager iter2 = queryParser.findUsers(query2, context).pager();
99 Pager<String> allUsers = ldapUserManager.getUserNames();
100 assertEquals(PagerUtils.count(allUsers), PagerUtils.count(iter2));
101 }
102
103 public void testParseSingleUserQuery() throws EntityException
104 {
105 UserNameTermQuery query = new UserNameTermQuery(USERNAME_1);
106 String finalQuery = "(" + ldapSearchProperties.getUsernameAttribute() + "=" + USERNAME_1 + ")";
107
108 assertEquals("parserEntity is not rendering ldap query correctly",
109 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
110
111 Pager iter = queryParser.findUsers(query, context).pager();
112 List list = PagerUtils.toList(iter);
113 assertEquals(1, list.size());
114 assertEquals(ldapUserManager.getUser(USERNAME_1), list.get(0));
115 }
116
117 public void testParseSingleUserQuerySubstringMatch() throws EntityException
118 {
119 UserNameTermQuery query = new UserNameTermQuery("bob", TermQuery.SUBSTRING_STARTS_WITH);
120 String finalQuery = "(" + ldapSearchProperties.getUsernameAttribute() + "=" + "bob*)";
121
122 assertEquals("parserEntity is not rendering ldap query correctly",
123 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
124
125 query = new UserNameTermQuery("fred", TermQuery.SUBSTRING_ENDS_WITH);
126
127 finalQuery = "(" + ldapSearchProperties.getUsernameAttribute() + "=" + "*fred)";
128
129 assertEquals("parserEntity is not rendering ldap query correctly",
130 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
131
132 query = new UserNameTermQuery("mary", TermQuery.SUBSTRING_CONTAINS);
133
134 finalQuery = "(" + ldapSearchProperties.getUsernameAttribute() + "=" + "*mary*)";
135
136 assertEquals("parserEntity is not rendering ldap query correctly",
137 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
138
139 query = new UserNameTermQuery("user", TermQuery.SUBSTRING_STARTS_WITH);
140 Pager iter = queryParser.findUsers(query, context).pager();
141 List list = PagerUtils.toList(iter);
142
143 assertEquals(8, list.size());
144 }
145
146 public void testParseTwoUserORQuery() throws EntityException
147 {
148 UserNameTermQuery query1 = new UserNameTermQuery(USERNAME_1);
149 UserNameTermQuery query2 = new UserNameTermQuery(USERNAME_2);
150
151 BooleanQuery query = new MultiTermBooleanQuery(new Query[]{query1, query2}, false);
152
153 String finalQuery = "(|(" + ldapSearchProperties.getUsernameAttribute() + "=" + USERNAME_1 + ")"
154 + "(" + ldapSearchProperties.getUsernameAttribute() + "=" + USERNAME_2 + "))";
155
156 assertEquals("parserEntity is not rendering ldap query correctly",
157 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
158
159 Pager iter = queryParser.findUsers(query, context).pager();
160 List list = PagerUtils.toList(iter);
161
162 assertEquals(2, list.size());
163
164 boolean ldapuseraFound = false;
165 boolean ldapuserbFound = false;
166
167 for (int i = 0; i < list.size(); i++)
168 {
169 User u = (User) list.get(i);
170
171 if (!ldapuseraFound)
172 {
173 if (u.equals(ldapUserManager.getUser(USERNAME_1)))
174 {
175 ldapuseraFound = true;
176 }
177
178 continue;
179 }
180
181 if (!ldapuserbFound && u.equals(ldapUserManager.getUser(USERNAME_2)))
182 {
183 ldapuserbFound = true;
184 }
185 }
186
187 assertTrue(ldapuseraFound);
188 assertTrue(ldapuserbFound);
189 }
190
191 public void testFullNameTermQuery() throws Exception
192 {
193 FullNameTermQuery query = new FullNameTermQuery("sn1");
194
195 String finalQuery = "(|(" + ldapSearchProperties.getFirstnameAttribute() + "=" + "sn1" + ")(" +
196 ldapSearchProperties.getSurnameAttribute() + "=" + "sn1" + "))";
197
198 assertEquals("parserEntity is not rendering ldap query correctly",
199 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
200
201 Pager iter = queryParser.findUsers(query, context).pager();
202 List list = PagerUtils.toList(iter);
203 assertEquals(1, list.size());
204 assertEquals(ldapUserManager.getUser(USERNAME_1), list.get(0));
205 }
206
207 public void testEmailTermQuery() throws EntityException
208 {
209 EmailTermQuery query = new EmailTermQuery("user1@example.com");
210
211 String finalQuery = "(" + ldapSearchProperties.getEmailAttribute() + "=user1@example.com)";
212
213 assertEquals("parserEntity is not rendering ldap query correctly",
214 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
215
216 Pager iter = queryParser.findUsers(query, context).pager();
217 List list = PagerUtils.toList(iter);
218 assertEquals(1, list.size());
219 assertEquals(ldapUserManager.getUser(USERNAME_1), list.get(0));
220 }
221
222 public void testEmailTermQuerySubstringMatching() throws EntityException
223 {
224 EmailTermQuery query = new EmailTermQuery("user1@", TermQuery.SUBSTRING_CONTAINS);
225
226 String finalQuery = "(" + ldapSearchProperties.getEmailAttribute() + "=*user1@*)";
227
228 assertEquals("parserEntity is not rendering ldap query correctly",
229 finalQuery, ((LDAPEntityQueryParser) queryParser).parseQuery(query).toString());
230
231 Pager iter = queryParser.findUsers(query, context).pager();
232 List list = PagerUtils.toList(iter);
233 assertEquals(1, list.size());
234 assertEquals(ldapUserManager.getUser(USERNAME_1), list.get(0));
235 }
236
237 protected String getLdapConfigLocation()
238 {
239 return "classpath:com/atlassian/user/impl/ldap/static/flat/ldapTestStaticFlatContext.xml";
240 }
241
242 public void setLdapUserManager(UserManager ldapUserManager)
243 {
244 this.ldapUserManager = ldapUserManager;
245 }
246
247 public void setLdapIdentifier(RepositoryIdentifier ldapIdentifier)
248 {
249 this.ldapIdentifier = ldapIdentifier;
250 }
251
252 public void setLdapSearchProperties(LdapSearchProperties ldapSearchProperties)
253 {
254 this.ldapSearchProperties = ldapSearchProperties;
255 }
256
257 public void setLdapGroupAdaptor(LDAPGroupAdaptor ldapGroupAdaptor)
258 {
259 this.ldapGroupAdaptor = ldapGroupAdaptor;
260 }
261
262 public void setLdapContextFactory(LdapContextFactory ldapContextFactory)
263 {
264 this.ldapContextFactory = ldapContextFactory;
265 }
266
267 public void setLdapMembershipProperties(LdapMembershipProperties ldapMembershipProperties)
268 {
269 this.ldapMembershipProperties = ldapMembershipProperties;
270 }
271
272 public void setLdapFilterFactory(LdapFilterFactory ldapFilterFactory)
273 {
274 this.ldapFilterFactory = ldapFilterFactory;
275 }
276 }