1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.bremersee.ldaptive;
18
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertFalse;
21 import static org.junit.jupiter.api.Assertions.assertNotNull;
22 import static org.junit.jupiter.api.Assertions.assertNull;
23 import static org.junit.jupiter.api.Assertions.assertThrows;
24 import static org.junit.jupiter.api.Assertions.assertTrue;
25
26 import java.util.Arrays;
27 import java.util.Collection;
28 import java.util.LinkedHashSet;
29 import java.util.Optional;
30 import java.util.Set;
31 import java.util.UUID;
32 import org.apache.commons.logging.Log;
33 import org.apache.commons.logging.LogFactory;
34 import org.bremersee.exception.ServiceException;
35 import org.bremersee.ldaptive.app.Group;
36 import org.bremersee.ldaptive.app.GroupMapper;
37 import org.bremersee.ldaptive.app.Person;
38 import org.bremersee.ldaptive.app.PersonMapper;
39 import org.bremersee.ldaptive.app.TestConfiguration;
40 import org.junit.jupiter.api.BeforeAll;
41 import org.junit.jupiter.api.Test;
42 import org.ldaptive.AddRequest;
43 import org.ldaptive.CompareRequest;
44 import org.ldaptive.DeleteRequest;
45 import org.ldaptive.FilterTemplate;
46 import org.ldaptive.LdapAttribute;
47 import org.ldaptive.LdapEntry;
48 import org.ldaptive.ModifyDnRequest;
49 import org.ldaptive.ModifyRequest;
50 import org.ldaptive.SearchRequest;
51 import org.ldaptive.SearchScope;
52 import org.ldaptive.SimpleBindRequest;
53 import org.springframework.beans.factory.annotation.Autowired;
54 import org.springframework.beans.factory.annotation.Value;
55 import org.springframework.boot.ldap.autoconfigure.embedded.EmbeddedLdapProperties;
56 import org.springframework.boot.test.context.SpringBootTest;
57 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
58 import org.springframework.test.util.TestSocketUtils;
59
60
61
62
63
64
65 @SpringBootTest(
66 classes = {TestConfiguration.class},
67 webEnvironment = WebEnvironment.NONE,
68 properties = {
69 "spring.ldap.embedded.base-dn=dc=bremersee,dc=org",
70 "spring.ldap.embedded.credential.username=uid=admin",
71 "spring.ldap.embedded.credential.password=secret",
72 "spring.ldap.embedded.ldif=classpath:schema.ldif",
73 "spring.ldap.embedded.validation.enabled=false"
74 })
75 class LdaptiveTemplateTest {
76
77
78
79
80 EmbeddedLdapProperties k;
81
82 private static final Log log = LogFactory.getLog(LdaptiveTemplateTest.class);
83
84 @Value("${spring.ldap.embedded.base-dn}")
85 private String baseDn;
86
87 @Autowired
88 private LdaptiveTemplate ldaptiveTemplate;
89
90 @Autowired
91 private PersonMapper personMapper;
92
93 @Autowired
94 private GroupMapper groupMapper;
95
96
97
98
99 @BeforeAll
100 static void setEmbeddedLdapPort() {
101 int embeddedLdapPort = TestSocketUtils.findAvailableTcpPort();
102 System.setProperty("spring.ldap.embedded.port", String.valueOf(embeddedLdapPort));
103 }
104
105
106
107
108 @Test
109 void hasBindConnectionInitializer() {
110 boolean actual = ldaptiveTemplate.hasBindConnectionInitializer();
111 assertTrue(actual);
112 }
113
114
115
116
117 @Test
118 void findExistingPersons() {
119 SearchRequest searchRequest = SearchRequest.builder()
120 .dn("ou=people," + baseDn)
121 .filter("(objectclass=inetOrgPerson)")
122 .scope(SearchScope.ONELEVEL)
123 .build();
124
125
126 Collection<LdapEntry> entries = ldaptiveTemplate.findAll(searchRequest);
127 entries.forEach(ldapEntry -> log.info(String.format("Ldap entry found with cn = %s",
128 ldapEntry.getAttribute("cn").getStringValue())));
129 assertTrue(entries.stream()
130 .anyMatch(entry -> "Anna Livia Plurabelle"
131 .equalsIgnoreCase(entry.getAttribute("cn").getStringValue())));
132 assertTrue(entries.stream()
133 .anyMatch(entry -> "Gustav Anias Horn"
134 .equalsIgnoreCase(entry.getAttribute("cn").getStringValue())));
135 assertTrue(entries.stream()
136 .anyMatch(entry -> "Hans Castorp"
137 .equalsIgnoreCase(entry.getAttribute("cn").getStringValue())));
138
139
140 assertTrue(ldaptiveTemplate.findAll(searchRequest, personMapper)
141 .anyMatch(entry -> "Anna Livia Plurabelle"
142 .equalsIgnoreCase(entry.getCn())));
143 assertTrue(ldaptiveTemplate.findAll(searchRequest, personMapper)
144 .anyMatch(entry -> "Gustav Anias Horn"
145 .equalsIgnoreCase(entry.getCn())));
146 assertTrue(ldaptiveTemplate.findAll(searchRequest, personMapper)
147 .anyMatch(entry -> "Hans Castorp"
148 .equalsIgnoreCase(entry.getCn())));
149 }
150
151
152
153
154 @Test
155 void findExistingGroups() {
156 SearchRequest searchRequest = SearchRequest.builder()
157 .dn("ou=groups," + baseDn)
158 .filter("(objectclass=groupOfUniqueNames)")
159 .scope(SearchScope.ONELEVEL)
160 .build();
161
162
163 Collection<LdapEntry> entries = ldaptiveTemplate.findAll(searchRequest);
164 entries.forEach(ldapEntry -> log.info(String.format("Ldap entry found with cn = %s",
165 ldapEntry.getAttribute("cn").getStringValue())));
166 assertTrue(entries.stream()
167 .anyMatch(entry -> "developers"
168 .equalsIgnoreCase(entry.getAttribute("cn").getStringValue())));
169 assertTrue(entries.stream()
170 .anyMatch(entry -> "managers"
171 .equalsIgnoreCase(entry.getAttribute("cn").getStringValue())));
172
173
174 assertTrue(ldaptiveTemplate.findAll(searchRequest, groupMapper)
175 .anyMatch(entry -> "developers"
176 .equalsIgnoreCase(entry.getCn())));
177 assertTrue(ldaptiveTemplate.findAll(searchRequest, groupMapper)
178 .anyMatch(entry -> "managers"
179 .equalsIgnoreCase(entry.getCn())));
180 }
181
182
183
184
185 @Test
186 void findOneAndExpectSizeLimitExceeded() {
187 SearchRequest searchRequest = SearchRequest.builder()
188 .dn("ou=people," + baseDn)
189 .filter(FilterTemplate.builder()
190 .filter("(objectclass=inetOrgPerson)")
191 .build())
192 .scope(SearchScope.ONELEVEL)
193 .sizeLimit(1)
194 .build();
195
196 assertThrows(LdaptiveException.class, () -> ldaptiveTemplate.findOne(searchRequest));
197 }
198
199
200
201
202 @Test
203 void findExistingPerson() {
204 SearchRequest searchRequest = SearchRequest.builder()
205 .dn("ou=people," + baseDn)
206 .filter(FilterTemplate.builder()
207 .filter("(&(objectclass=inetOrgPerson)(uid={0}))")
208 .parameters("anna")
209 .build())
210 .scope(SearchScope.ONELEVEL)
211 .sizeLimit(1)
212 .build();
213
214 Optional<LdapEntry> entry = ldaptiveTemplate.findOne(searchRequest);
215 assertTrue(entry.isPresent());
216 assertEquals("anna", entry.get().getAttribute("uid").getStringValue());
217
218 Optional<Person> person = ldaptiveTemplate.findOne(searchRequest, personMapper);
219 assertTrue(person.isPresent());
220 assertEquals("anna", person.get().getUid());
221 }
222
223
224
225
226 @Test
227 void findExistingPersonByDn() {
228 String dn = "uid=anna,ou=people," + baseDn;
229 Optional<LdapEntry> entry = ldaptiveTemplate
230 .findOne(SearchRequest.objectScopeSearchRequest(dn));
231 assertTrue(entry.isPresent());
232 }
233
234
235
236
237 @Test
238 void findNonExistingPerson() {
239 SearchRequest searchRequest = SearchRequest.builder()
240 .dn("ou=people," + baseDn)
241 .filter(FilterTemplate.builder()
242 .filter("(&(objectclass=inetOrgPerson)(uid={0}))")
243 .parameters(UUID.randomUUID().toString().replace("-", ""))
244 .build())
245 .scope(SearchScope.ONELEVEL)
246 .build();
247
248 Optional<LdapEntry> entry = ldaptiveTemplate.findOne(searchRequest);
249 assertFalse(entry.isPresent());
250 }
251
252
253
254
255 @Test
256 void findNonExistingPersonByDn() {
257 String uid = UUID.randomUUID().toString().replace("-", "");
258 String dn = "uid=" + uid + ",ou=people," + baseDn;
259 Optional<LdapEntry> entry = ldaptiveTemplate
260 .findOne(SearchRequest.objectScopeSearchRequest(dn));
261 assertFalse(entry.isPresent());
262 }
263
264
265
266
267 @Test
268 void generateUserPasswordAndBind() {
269 String dn = "uid=anna,ou=people," + baseDn;
270
271 String initPasswd = ldaptiveTemplate.generateUserPassword(dn);
272 assertNotNull(initPasswd);
273
274 String newPasswd = initPasswd + "Pass1234";
275 ldaptiveTemplate.modifyUserPassword(dn, initPasswd, newPasswd);
276
277 boolean success = ldaptiveTemplate.bind(SimpleBindRequest.builder()
278 .dn(dn)
279 .password(newPasswd)
280 .build());
281 assertTrue(success);
282
283 success = ldaptiveTemplate.bind(SimpleBindRequest.builder()
284 .dn(dn)
285 .password(initPasswd + "f")
286 .build());
287 assertFalse(success);
288 }
289
290
291
292
293 @Test
294 void setUserPasswordFails() {
295 String dn = "uid=hans,ou=people," + baseDn;
296
297 String initPasswd = ldaptiveTemplate.generateUserPassword(dn);
298 assertNotNull(initPasswd);
299
300 String newPasswd = initPasswd + "Pass1234";
301 assertThrows(ServiceException.class, () -> ldaptiveTemplate
302 .modifyUserPassword(dn, "wrong", newPasswd));
303 }
304
305
306
307
308 @Test
309 void existsGroup() {
310 Group group = new Group();
311 group.setCn("developers");
312 assertTrue(ldaptiveTemplate.exists(group, groupMapper));
313 group.setCn("na");
314 assertFalse(ldaptiveTemplate.exists(group, groupMapper));
315 }
316
317
318
319
320 @Test
321 void compareGroup() {
322 Group group = new Group();
323 group.setCn("developers");
324
325 assertTrue(ldaptiveTemplate.compare(CompareRequest.builder()
326 .dn(groupMapper.mapDn(group))
327 .name("ou")
328 .value("developer")
329 .build()));
330
331 assertFalse(ldaptiveTemplate.compare(CompareRequest.builder()
332 .dn(groupMapper.mapDn(group))
333 .name("ou")
334 .value("manager")
335 .build()));
336
337 assertFalse(ldaptiveTemplate.compare(CompareRequest.builder()
338 .dn(groupMapper.mapDn(group))
339 .name("notexists")
340 .value("manager")
341 .build()));
342
343 group.setCn("notexists");
344 CompareRequest cr = CompareRequest.builder()
345 .dn(groupMapper.mapDn(group))
346 .name("ou")
347 .value("developer")
348 .build();
349 assertThrows(ServiceException.class, () -> ldaptiveTemplate.compare(cr));
350 }
351
352
353
354
355 @Test
356 void addAndModifyAndDeletePerson() {
357 Person person = new Person();
358 person.setCn("A person");
359 person.setSn("Person");
360 person.setUid("person");
361
362 String dn = personMapper.mapDn(person);
363 LdapEntry destination = new LdapEntry();
364 personMapper.map(person, destination);
365 destination.setDn(dn);
366 destination.addAttributes(new LdapAttribute(
367 "objectclass",
368 personMapper.getObjectClasses()));
369 ldaptiveTemplate.add(new AddRequest(dn, destination.getAttributes()));
370 assertTrue(ldaptiveTemplate.exists(person, personMapper));
371
372 person.setSn("Surname");
373 ModifyRequest modifyRequest = personMapper
374 .mapAndComputeModifyRequest(person, destination)
375 .orElseThrow();
376 ldaptiveTemplate.modify(modifyRequest);
377
378 person = ldaptiveTemplate.findOne(SearchRequest.objectScopeSearchRequest(dn), personMapper)
379 .orElseThrow(() -> ServiceException.notFound("Person", "person"));
380 assertEquals("Surname", person.getSn());
381
382 person.setSn("");
383 modifyRequest = personMapper
384 .mapAndComputeModifyRequest(person, destination)
385 .orElseThrow();
386 ldaptiveTemplate.modify(modifyRequest);
387
388 person = ldaptiveTemplate.findOne(SearchRequest.objectScopeSearchRequest(dn), personMapper)
389 .orElseThrow(() -> ServiceException.notFound("Person", "person"));
390 assertNull(person.getSn());
391
392 ldaptiveTemplate.delete(new DeleteRequest(dn));
393 assertFalse(ldaptiveTemplate.exists(person, personMapper));
394 }
395
396
397
398
399 @Test
400 void saveAndRemoveGroup() {
401 Group group = new Group();
402 group.setCn("party");
403 group.setOu("Party Guests");
404
405 Set<String> members = new LinkedHashSet<>();
406 members.add("uid=anna,ou=people," + baseDn);
407 group.setMembers(members);
408
409 group = ldaptiveTemplate.save(group, groupMapper);
410 assertNotNull(group);
411
412 SearchRequest searchRequest = SearchRequest.builder()
413 .dn("ou=groups," + baseDn)
414 .filter(FilterTemplate.builder()
415 .filter("(&(objectclass=groupOfUniqueNames)(cn={0}))")
416 .parameters("party")
417 .build())
418 .scope(SearchScope.ONELEVEL)
419 .build();
420
421 group = ldaptiveTemplate.findOne(searchRequest, groupMapper)
422 .orElseThrow(() -> ServiceException.notFound("Group", "party"));
423 assertEquals("party", group.getCn());
424 assertEquals("Party Guests", group.getOu());
425 assertTrue(group.getMembers().contains("uid=anna,ou=people," + baseDn));
426
427 group.getMembers().add("uid=hans,ou=people," + baseDn);
428 group.getMembers().add("uid=gustav,ou=people," + baseDn);
429 group = ldaptiveTemplate.save(group, groupMapper);
430 assertNotNull(group);
431
432 group = ldaptiveTemplate.findOne(searchRequest, groupMapper)
433 .orElseThrow(() -> ServiceException.notFound("Group", "party"));
434 assertEquals("party", group.getCn());
435 assertEquals("Party Guests", group.getOu());
436 assertTrue(group.getMembers().contains("uid=anna,ou=people," + baseDn));
437 assertTrue(group.getMembers().contains("uid=hans,ou=people," + baseDn));
438 assertTrue(group.getMembers().contains("uid=gustav,ou=people," + baseDn));
439
440 group.getMembers().remove("uid=hans,ou=people," + baseDn);
441 group = ldaptiveTemplate.save(group, groupMapper);
442 assertNotNull(group);
443
444 group = ldaptiveTemplate.findOne(searchRequest, groupMapper)
445 .orElseThrow(() -> ServiceException.notFound("Group", "party"));
446 assertEquals("party", group.getCn());
447 assertEquals("Party Guests", group.getOu());
448 assertTrue(group.getMembers().contains("uid=anna,ou=people," + baseDn));
449 assertTrue(group.getMembers().contains("uid=gustav,ou=people," + baseDn));
450 assertFalse(group.getMembers().contains("uid=hans,ou=people," + baseDn));
451
452 ldaptiveTemplate.remove(group, groupMapper);
453 assertFalse(ldaptiveTemplate.exists(group, groupMapper));
454 }
455
456
457
458
459 @Test
460 void saveAndRemovePersons() {
461 Person p0 = new Person();
462 p0.setCn("Person Number 0");
463 p0.setSn("Person 0");
464 p0.setUid("person0");
465 Person p1 = new Person();
466 p1.setCn("Person Number 1");
467 p1.setSn("Person 1");
468 p1.setUid("person1");
469 Person p2 = new Person();
470 p2.setCn("Person Number 2");
471 p2.setSn("Person 2");
472 p2.setUid("person2");
473
474 ldaptiveTemplate.saveAll(Arrays.asList(p0, p1, p2), personMapper)
475 .forEach(person -> log.info(String.format("New person: %s", person)));
476 assertTrue(ldaptiveTemplate.exists(p0, personMapper));
477 assertTrue(ldaptiveTemplate.exists(p1, personMapper));
478 assertTrue(ldaptiveTemplate.exists(p2, personMapper));
479
480 ldaptiveTemplate.removeAll(Arrays.asList(p0, p1, p2), personMapper);
481 assertFalse(ldaptiveTemplate.exists(p0, personMapper));
482 assertFalse(ldaptiveTemplate.exists(p1, personMapper));
483 assertFalse(ldaptiveTemplate.exists(p2, personMapper));
484 }
485
486
487
488
489 @Test
490 void modifyDn() {
491 Person p0 = new Person();
492 p0.setCn("Gottfried");
493 p0.setSn("Benn");
494 p0.setUid("benn");
495
496 p0 = ldaptiveTemplate.save(p0, personMapper);
497 assertNotNull(p0);
498
499 ldaptiveTemplate.modifyDn(ModifyDnRequest.builder()
500 .oldDN(personMapper.mapDn(p0))
501 .newRDN("uid=gbn")
502 .delete(true)
503 .build());
504
505 Optional<Person> pr = ldaptiveTemplate.findAll(
506 SearchRequest.builder()
507 .dn("ou=people," + baseDn)
508 .filter("(sn=Benn)")
509 .build(),
510 personMapper)
511 .filter(p -> "gbn".equals(p.getUid()))
512 .findAny();
513 assertTrue(pr.isPresent());
514
515 ldaptiveTemplate.delete(DeleteRequest.builder().dn(personMapper.mapDn(pr.get())).build());
516 }
517
518
519
520
521 @Test
522 void testCopy() {
523 LdaptiveTemplate clone = ldaptiveTemplate.copy();
524 clone.setErrorHandler(new DefaultLdaptiveErrorHandler());
525 Group group = new Group();
526 group.setCn("developers");
527 assertTrue(clone.exists(group, groupMapper));
528 group.setCn("na");
529 assertFalse(clone.exists(group, groupMapper));
530 }
531
532 }