View Javadoc
1   /*
2    * Copyright 2019-2026 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
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   * The ldaptive template test.
62   *
63   * @author Christian Bremer
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     * The K.
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     * Sets embedded ldap port.
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    * Has bind connection initializer.
107    */
108   @Test
109   void hasBindConnectionInitializer() {
110     boolean actual = ldaptiveTemplate.hasBindConnectionInitializer();
111     assertTrue(actual);
112   }
113 
114   /**
115    * Find existing persons.
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     // without mapper
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     // with mapper
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    * Find existing groups.
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     // without mapper
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     // with mapper
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    * Find one existing person.
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    * Find existing person.
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    * Find existing person by dn.
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    * Find non existing person.
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    * Find non existing person by dn.
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    * Generate user password and bind.
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    * Set user password fails.
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    * Exists group.
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    * Compare group.
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    * Add and modify and delete person.
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    * Save and remove group.
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    * Save and delete persons.
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    * Modify dn.
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    * Test clone.
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 }