1 /*****************************************************************************
5 * Creation date 12 Oct 2012
8 *****************************************************************************/
9 package test.splat.service;
11 import java.util.ArrayList;
12 import java.util.Calendar;
13 import java.util.Date;
14 import java.util.Iterator;
15 import java.util.List;
17 import org.splat.dal.bo.kernel.User;
18 import org.splat.dal.bo.som.ContributorRelation;
19 import org.splat.dal.bo.som.DocumentType;
20 import org.splat.dal.bo.som.KnowledgeElement;
21 import org.splat.dal.bo.som.KnowledgeElementType;
22 import org.splat.dal.bo.som.Scenario;
23 import org.splat.dal.bo.som.SimulationContext;
24 import org.splat.dal.bo.som.Study;
25 import org.splat.dal.bo.som.ValidationCycle;
26 import org.splat.dal.bo.som.ValidationCycleRelation;
27 import org.splat.dal.bo.som.ValidationStep;
28 import org.splat.dal.bo.som.Visibility;
29 import org.splat.dal.dao.kernel.UserDAO;
30 import org.splat.dal.dao.som.Database;
31 import org.splat.dal.dao.som.KnowledgeElementDAO;
32 import org.splat.dal.dao.som.KnowledgeElementTypeDAO;
33 import org.splat.dal.dao.som.ScenarioDAO;
34 import org.splat.dal.dao.som.StudyDAO;
35 import org.splat.dal.dao.som.ValidationCycleDAO;
36 import org.splat.exception.BusinessException;
37 import org.splat.log.AppLogger;
38 import org.splat.service.DocumentTypeService;
39 import org.splat.service.PublicationService;
40 import org.splat.service.SearchService;
41 import org.splat.service.SimulationContextService;
42 import org.splat.service.StepService;
43 import org.splat.service.StudyService;
44 import org.splat.service.dto.KnowledgeSearchFilterDTO;
45 import org.splat.service.dto.Proxy;
46 import org.splat.service.dto.StudySearchFilterDTO;
47 import org.splat.service.technical.ProjectSettingsService;
48 import org.springframework.beans.factory.annotation.Autowired;
49 import org.springframework.beans.factory.annotation.Qualifier;
50 import org.springframework.orm.hibernate3.HibernateTemplate;
51 import org.testng.Assert;
52 import org.testng.annotations.Test;
54 import test.splat.common.BaseTest;
55 import test.splat.util.TestEntitiesGenerator;
58 * Test class for StudyService.
60 * @author <a href="mailto:roman.kozlov@opencascade.com">Roman Kozlov (RKV)</a>
63 public class TestSearchService extends BaseTest {
66 * Logger for the class.
68 private static final AppLogger LOG = AppLogger
69 .getLogger(TestSearchService.class);
72 * The StudyDAO. Later injected by Spring.
75 @Qualifier("studyDAO")
76 private transient StudyDAO _studyDAO;
79 * The ScenarioDAO. Later injected by Spring.
82 @Qualifier("scenarioDAO")
83 private transient ScenarioDAO _scenarioDAO;
86 * The KnowledgeElementDAO. Later injected by Spring.
89 @Qualifier("knowledgeElementDAO")
90 private transient KnowledgeElementDAO _knowledgeElementDAO;
93 * The KnowledgeElementTypeDAO. Later injected by Spring.
96 @Qualifier("knowledgeElementTypeDAO")
97 private transient KnowledgeElementTypeDAO _knowledgeElementTypeDAO;
100 * The PublicationService. Later injected by Spring.
103 @Qualifier("publicationService")
104 private transient PublicationService _publicationService;
107 * The StepService. Later injected by Spring.
110 @Qualifier("stepService")
111 private transient StepService _stepService;
114 * The ProjectSettingsService. Later injected by Spring.
117 @Qualifier("projectSettings")
118 private transient ProjectSettingsService _projectSettings;
121 * The DocumentTypeService. Later injected by Spring.
124 @Qualifier("documentTypeService")
125 private transient DocumentTypeService _documentTypeService;
128 * The StudyService. Later injected by Spring.
131 @Qualifier("studyService")
132 private transient StudyService _studyService;
135 * The SearchService. Later injected by Spring.
138 @Qualifier("searchService")
139 private transient SearchService _searchService;
142 * The UserDAO. Later injected by Spring.
145 @Qualifier("userDAO")
146 private transient UserDAO _userDAO;
149 * The ValidationCycleDAO. Later injected by Spring.
152 @Qualifier("validationCycleDAO")
153 private transient ValidationCycleDAO _validationCycleDAO;
156 * The SimulationContextService. Later injected by Spring.
159 @Qualifier("simulationContextService")
160 private transient SimulationContextService _simulationContextService;
163 * Test of searching a study.<BR>
164 * <B>Description :</B> <BR>
165 * <i>Create studies and try to find them according next document index.</i><BR>
166 * <B>Action : </B><BR>
169 * <li>Search study by state</li>
170 * <li>Search study by reference</li>
171 * <li>Search study by author</li>
172 * <li>Search study by actor</li>
173 * <li>Search study by title</li>
174 * <li>Search study by simulation contexts</li>
175 * <li>Search study by all criteria</li>
176 * <li>Search study by any criteria</li>
178 * </i> <B>Test data : </B><BR>
179 * <i>no input parameters</i><BR>
181 * <B>Outcome results:</B><BR>
184 * <li>A study must be found according to the given criteria<BR>
189 * @throws BusinessException
190 * if can't create test user or study
193 public void testSelectStudiesWhere() throws BusinessException {
194 LOG.debug(">>>>> BEGIN testSelectStudiesWhere()");
195 startNestedTransaction();
197 HibernateTemplate ht = getHibernateTemplate();
198 Calendar calend = java.util.Calendar.getInstance();
199 calend.roll(Calendar.DATE, false);
200 Date beforeCreation = calend.getTime();
202 Database.getInstance().reset();
203 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
204 // Load workflow customization
206 _projectSettings.configure(ClassLoader.getSystemResource(
207 "test/som.xml").getPath());
208 } catch (Exception e) {
209 Assert.fail("Can't load som.xml: ", e);
212 User goodUser = TestEntitiesGenerator.getTestUser("goodUser");
213 _userDAO.create(goodUser);
214 User otherUser = TestEntitiesGenerator.getTestUser("otherUser");
215 _userDAO.create(otherUser);
216 User thirdUser = TestEntitiesGenerator.getTestUser("thirdUser");
217 _userDAO.create(thirdUser);
219 // ============== STUDY 0: Private : goodUser
220 // Create private study
221 Study aStudy = TestEntitiesGenerator.getTestStudy(goodUser);
222 aStudy.setTitle("0.This is private study");
223 Long privateStudyId = _studyDAO.create(aStudy);
225 // Add simulation context to the study 0
226 SimulationContext.Properties cprop = new SimulationContext.Properties();
227 cprop.setType(_simulationContextService.selectType("product"))
228 .setValue("Test Simulation Context: Product");
229 SimulationContext ctx = _studyService.addProjectContext(aStudy, cprop);
232 // ============== STUDY 1: Public : goodUser : otherUser is contributor
233 // Create public study with predefined title
234 aStudy = TestEntitiesGenerator.getTestStudy(goodUser);
235 aStudy.setVisibility(Visibility.PUBLIC);
236 aStudy.setTitle("2.This is a public study");
237 aStudy.addRelation(new ContributorRelation(aStudy, otherUser));
238 Long titleStudyId = _studyDAO.create(aStudy);
240 // Add simulation context to the study 1
241 cprop.setType(_simulationContextService.selectType("product"))
242 .setValue("Test Simulation Context: Product1");
243 _studyService.addProjectContext(aStudy, cprop);
246 // ============== STUDY 2: Public : otherUser
247 // Create public study with predefined reference
248 aStudy = TestEntitiesGenerator.getTestStudy(otherUser);
249 aStudy.setVisibility(Visibility.PUBLIC);
250 aStudy.setTitle("1.This is another public study");
251 aStudy.setReference("TEST_REF");
252 Long refStudyId = _studyDAO.create(aStudy);
254 // ============== STUDY 3: Private : thirdUser : otherUser is contributor
255 // Create private study of third user with otherUser as a reviewer
256 aStudy = TestEntitiesGenerator.getTestStudy(thirdUser);
257 aStudy.setTitle("3.This is a private study of third user");
258 Long reviewStudyId = _studyDAO.create(aStudy);
260 // Create validation cycle for the last study
261 ValidationCycle.Properties vprop = new ValidationCycle.Properties();
262 DocumentType type = _documentTypeService.selectType("specification");
263 vprop.setDocumentType(type);
264 vprop.setActor(ValidationStep.REVIEW, otherUser);
265 ValidationCycle cycle = new ValidationCycle(aStudy, vprop);
266 _validationCycleDAO.create(cycle);
267 ValidationCycleRelation link = cycle.getContext();
268 aStudy.addRelation(link);
270 calend = java.util.Calendar.getInstance();
271 calend.roll(Calendar.DATE, true);
272 Date afterCreation = calend.getTime();
274 // ============== START OF TEST CALLS
275 // Search by study author
276 StudySearchFilterDTO filter = new StudySearchFilterDTO();
277 filter.setAuthor(String.valueOf(goodUser.getIndex()));
278 List<Proxy> res = _searchService.selectStudiesWhere(filter);
279 Assert.assertNotNull(res);
280 Assert.assertEquals(res.size(), 1);
281 Assert.assertEquals(res.get(0).getIndex(), titleStudyId);
283 // Search for other logged in study contributor
284 filter = new StudySearchFilterDTO();
285 filter.setConnectedUserId(otherUser.getIndex());
286 res = _searchService.selectStudiesWhere(filter);
287 Assert.assertNotNull(res);
288 Assert.assertEquals(res.size(), 3);
289 Assert.assertEquals(res.get(0).getIndex(), refStudyId); // Public study
290 Assert.assertEquals(res.get(1).getIndex(), titleStudyId); // Public study
291 Assert.assertEquals(res.get(2).getIndex(), reviewStudyId); // OtherUser is reviewer in this study
293 // Search for logged in study contributor
294 filter = new StudySearchFilterDTO();
295 filter.setConnectedUserId(goodUser.getIndex());
296 res = _searchService.selectStudiesWhere(filter);
297 Assert.assertNotNull(res);
298 Assert.assertEquals(res.size(), 3);
299 Assert.assertEquals(res.get(0).getIndex(), privateStudyId); // goodUser is author
300 Assert.assertEquals(res.get(1).getIndex(), refStudyId); // Public study
301 Assert.assertEquals(res.get(2).getIndex(), titleStudyId); // Public study
303 // Search by study title contents
304 filter = new StudySearchFilterDTO();
305 filter.setWords("study public");
306 res = _searchService.selectStudiesWhere(filter);
307 Assert.assertNotNull(res);
308 Assert.assertEquals(res.size(), 2);
309 Assert.assertEquals(res.get(0).getIndex(), refStudyId);
310 Assert.assertEquals(res.get(1).getIndex(), titleStudyId);
312 // Search by study reference
313 filter = new StudySearchFilterDTO();
314 filter.setReference("TEST_REF");
315 res = _searchService.selectStudiesWhere(filter);
316 Assert.assertNotNull(res);
317 Assert.assertEquals(res.size(), 1);
318 Assert.assertEquals(res.get(0).getIndex(), refStudyId);
320 // Search a study by simulation context
321 filter = new StudySearchFilterDTO();
322 filter.setConnectedUserId(goodUser.getIndex());
323 List<SimulationContext> contexts = new ArrayList<SimulationContext>();
325 filter.setSimContexts(contexts);
326 res = _searchService.selectStudiesWhere(filter);
327 Assert.assertNotNull(res);
328 Assert.assertEquals(res.size(), 1);
329 Assert.assertEquals(res.get(0).getIndex(), privateStudyId);
330 // Check simualtion contexts of the found study
331 for (Proxy proxy: res) {
332 aStudy = _studyService.selectStudy(proxy.getIndex());
333 Iterator<SimulationContext> ctxIter = aStudy
334 .SimulationContextIterator();
336 while (ctxIter.hasNext()) {
337 contexts.add(ctxIter.next());
339 Assert.assertEquals(contexts.size(), 1);
340 Assert.assertEquals(contexts.get(0), ctx);
344 filter = new StudySearchFilterDTO();
345 filter.setCreatedAfter(beforeCreation);
346 filter.setCreatedBefore(afterCreation);
347 res = _searchService.selectStudiesWhere(filter);
348 Assert.assertNotNull(res);
349 Assert.assertEquals(res.size(), 2);
350 Assert.assertEquals(res.get(0).getIndex(), refStudyId);
351 Assert.assertEquals(res.get(1).getIndex(), titleStudyId);
353 // Search for dates with no result
354 filter = new StudySearchFilterDTO();
355 filter.setCreatedAfter(afterCreation);
356 res = _searchService.selectStudiesWhere(filter);
357 Assert.assertNotNull(res);
358 Assert.assertEquals(res.size(), 0);
360 rollbackNestedTransaction();
361 LOG.debug(">>>>> END testSelectStudiesWhere()");
365 * Test of searching a study.<BR>
366 * <B>Description :</B> <BR>
367 * <i>Create studies and try to find them according next document index.</i><BR>
368 * <B>Action : </B><BR>
371 * <li>Search study by state</li>
372 * <li>Search study by reference</li>
373 * <li>Search study by author</li>
374 * <li>Search study by actor</li>
375 * <li>Search study by title</li>
376 * <li>Search study by simulation contexts</li>
377 * <li>Search study by all criteria</li>
378 * <li>Search study by any criteria</li>
380 * </i> <B>Test data : </B><BR>
381 * <i>no input parameters</i><BR>
383 * <B>Outcome results:</B><BR>
386 * <li>A study must be found according to the given criteria<BR>
391 * @throws BusinessException
392 * if can't create test user or study
395 public void testSelectKnowledgeElementsWhere() throws BusinessException {
396 LOG.debug(">>>>> BEGIN testSelectKnowledgeElementsWhere()");
397 startNestedTransaction();
399 HibernateTemplate ht = getHibernateTemplate();
401 Calendar calend = java.util.Calendar.getInstance();
402 calend.roll(Calendar.DATE, false);
403 Date beforeCreation = calend.getTime();
405 Database.getInstance().reset();
406 _projectSettings.getAllSteps().clear(); // Clear config to be able to load it again
407 // Load workflow customization
409 _projectSettings.configure(ClassLoader.getSystemResource(
410 "test/som.xml").getPath());
411 } catch (Exception e) {
412 Assert.fail("Can't load som.xml: ", e);
415 User goodUser = TestEntitiesGenerator.getTestUser("goodUser");
416 _userDAO.create(goodUser);
417 User otherUser = TestEntitiesGenerator.getTestUser("otherUser");
418 _userDAO.create(otherUser);
419 User thirdUser = TestEntitiesGenerator.getTestUser("thirdUser");
420 _userDAO.create(thirdUser);
421 KnowledgeElementType ktype1 = new KnowledgeElementType("testKType1");
422 KnowledgeElementType ktype2 = new KnowledgeElementType("testKType2");
423 _knowledgeElementTypeDAO.create(ktype1);
424 _knowledgeElementTypeDAO.create(ktype2);
426 // ============== STUDY 0: Private : goodUser
427 // Create private study
428 Study aStudy = TestEntitiesGenerator.getTestStudy(goodUser);
429 aStudy.setTitle("0.This is private study");
430 Long privateStudyId = _studyDAO.create(aStudy);
432 // Add simulation context to the study 0
433 SimulationContext.Properties cprop = new SimulationContext.Properties();
434 cprop.setType(_simulationContextService.selectType("product"))
435 .setValue("Test Simulation Context: Product");
436 SimulationContext ctx = _studyService.addProjectContext(aStudy, cprop);
439 // Add a scenario to the study 0
440 Scenario scen = TestEntitiesGenerator.getTestScenario(aStudy);
441 _scenarioDAO.create(scen);
444 // Add knowledge elements to the scenario
445 KnowledgeElement kelm01 = TestEntitiesGenerator
446 .getTestKnowledgeElement(scen, ktype1, "TestKelm01 title");
447 KnowledgeElement kelm02 = TestEntitiesGenerator
448 .getTestKnowledgeElement(scen, ktype2, "TestKelm02 title");
449 _knowledgeElementDAO.create(kelm01);
450 _knowledgeElementDAO.create(kelm02);
453 // ============== STUDY 1: Public : goodUser : otherUser is contributor
454 // Create public study with predefined title
455 aStudy = TestEntitiesGenerator.getTestStudy(goodUser);
456 aStudy.setVisibility(Visibility.PUBLIC);
457 aStudy.setTitle("2.This is a public study");
458 aStudy.addRelation(new ContributorRelation(aStudy, otherUser));
459 Long titleStudyId = _studyDAO.create(aStudy);
461 // Add a scenario to the study 1
462 scen = TestEntitiesGenerator.getTestScenario(aStudy);
463 _scenarioDAO.create(scen);
466 // Add knowledge elements to the scenario
467 KnowledgeElement kelm11 = TestEntitiesGenerator
468 .getTestKnowledgeElement(scen, ktype1, "TestKelm11 title");
469 KnowledgeElement kelm12 = TestEntitiesGenerator
470 .getTestKnowledgeElement(scen, ktype2, "TestKelm12 title");
471 _knowledgeElementDAO.create(kelm11);
472 _knowledgeElementDAO.create(kelm12);
474 // Add simulation context to the study 1
475 cprop.setType(_simulationContextService.selectType("product"))
476 .setValue("Test Simulation Context: Product1");
477 _studyService.addProjectContext(aStudy, cprop);
480 // ============== STUDY 2: Public : otherUser
481 // Create public study with predefined reference
482 aStudy = TestEntitiesGenerator.getTestStudy(otherUser);
483 aStudy.setVisibility(Visibility.PUBLIC);
484 aStudy.setTitle("1.This is another public study");
485 aStudy.setReference("TEST_REF");
486 Long refStudyId = _studyDAO.create(aStudy);
487 // Add a scenario to the study 2
488 scen = TestEntitiesGenerator.getTestScenario(aStudy);
489 _scenarioDAO.create(scen);
492 // Add knowledge elements to the scenario
493 KnowledgeElement kelm21 = TestEntitiesGenerator
494 .getTestKnowledgeElement(scen, ktype1, "TestKelm21 title");
495 KnowledgeElement kelm22 = TestEntitiesGenerator
496 .getTestKnowledgeElement(scen, ktype2, "TestKelm22 title");
497 _knowledgeElementDAO.create(kelm21);
498 _knowledgeElementDAO.create(kelm22);
501 // ============== STUDY 3: Private : thirdUser : otherUser is contributor
502 // Create private study of third user with otherUser as a reviewer
503 aStudy = TestEntitiesGenerator.getTestStudy(thirdUser);
504 aStudy.setTitle("3.This is a private study of third user");
505 Long reviewStudyId = _studyDAO.create(aStudy);
507 // Create validation cycle for the last study
508 ValidationCycle.Properties vprop = new ValidationCycle.Properties();
509 DocumentType type = _documentTypeService.selectType("specification");
510 vprop.setDocumentType(type);
511 vprop.setActor(ValidationStep.REVIEW, otherUser);
512 ValidationCycle cycle = new ValidationCycle(aStudy, vprop);
513 _validationCycleDAO.create(cycle);
514 ValidationCycleRelation link = cycle.getContext();
515 aStudy.addRelation(link);
517 // Add a scenario to the study 3
518 scen = TestEntitiesGenerator.getTestScenario(aStudy);
519 _scenarioDAO.create(scen);
522 // Add knowledge elements to the scenario
523 KnowledgeElement kelm31 = TestEntitiesGenerator
524 .getTestKnowledgeElement(scen, ktype1, "TestKelm31 title");
525 KnowledgeElement kelm32 = TestEntitiesGenerator
526 .getTestKnowledgeElement(scen, ktype2, "TestKelm32 title");
527 _knowledgeElementDAO.create(kelm31);
528 _knowledgeElementDAO.create(kelm32);
530 calend = java.util.Calendar.getInstance();
531 calend.roll(Calendar.DATE, true);
532 Date afterCreation = calend.getTime();
534 // ============== START OF TEST CALLS
535 // Search by author goodUser as not logged in user
536 KnowledgeSearchFilterDTO filter = new KnowledgeSearchFilterDTO();
537 filter.setAuthor(String.valueOf(goodUser.getIndex()));
538 List<Proxy> res = _searchService.selectKnowledgeElementsWhere(filter);
539 Assert.assertNotNull(res);
540 Assert.assertEquals(res.size(), 2);
541 Assert.assertEquals(res.get(0).getTitle(), kelm11.getTitle());
542 Assert.assertEquals(res.get(1).getTitle(), kelm12.getTitle());
544 // Search for other logged in study contributor (what is visible for otherUser by default)
545 filter = new KnowledgeSearchFilterDTO();
546 filter.setConnectedUserId(otherUser.getIndex());
547 res = _searchService.selectKnowledgeElementsWhere(filter);
548 Assert.assertNotNull(res);
549 Assert.assertEquals(res.size(), 6);
550 Assert.assertEquals(res.get(0).getTitle(), kelm11.getTitle());
551 Assert.assertEquals(res.get(1).getTitle(), kelm12.getTitle());
552 Assert.assertEquals(res.get(2).getTitle(), kelm21.getTitle());
553 Assert.assertEquals(res.get(3).getTitle(), kelm22.getTitle());
554 Assert.assertEquals(res.get(4).getTitle(), kelm31.getTitle());
555 Assert.assertEquals(res.get(5).getTitle(), kelm32.getTitle());
557 // Search for logged in study contributor
558 filter = new KnowledgeSearchFilterDTO();
559 filter.setConnectedUserId(goodUser.getIndex());
560 res = _searchService.selectKnowledgeElementsWhere(filter);
561 Assert.assertNotNull(res);
562 Assert.assertEquals(res.size(), 6);
563 Assert.assertEquals(res.get(0).getTitle(), kelm01.getTitle());
564 Assert.assertEquals(res.get(1).getTitle(), kelm02.getTitle());
565 Assert.assertEquals(res.get(2).getTitle(), kelm11.getTitle());
566 Assert.assertEquals(res.get(3).getTitle(), kelm12.getTitle());
567 Assert.assertEquals(res.get(4).getTitle(), kelm21.getTitle());
568 Assert.assertEquals(res.get(5).getTitle(), kelm22.getTitle());
570 // Search by title contents
571 filter = new KnowledgeSearchFilterDTO();
572 filter.setWords("TestKelm22");
573 res = _searchService.selectKnowledgeElementsWhere(filter);
574 Assert.assertNotNull(res);
575 Assert.assertEquals(res.size(), 1);
576 Assert.assertEquals(res.get(0).getTitle(), kelm22.getTitle());
578 // Search by reference
579 filter = new KnowledgeSearchFilterDTO();
580 filter.setReference(kelm22.getReference());
581 res = _searchService.selectKnowledgeElementsWhere(filter);
582 Assert.assertNotNull(res);
583 Assert.assertEquals(res.size(), 1);
584 Assert.assertEquals(res.get(0).getTitle(), kelm22.getTitle());
586 // Search by simulation context
587 filter = new KnowledgeSearchFilterDTO();
588 filter.setConnectedUserId(goodUser.getIndex());
589 List<SimulationContext> contexts = new ArrayList<SimulationContext>();
591 filter.setSimContexts(contexts);
592 res = _searchService.selectKnowledgeElementsWhere(filter);
593 Assert.assertNotNull(res);
594 Assert.assertEquals(res.size(), 2);
595 Assert.assertEquals(res.get(0).getTitle(), kelm01.getTitle());
596 Assert.assertEquals(res.get(1).getTitle(), kelm02.getTitle());
597 // Check simualtion contexts of the found study
598 for (Proxy proxy : res) {
599 KnowledgeElement kelm = _knowledgeElementDAO.get(proxy.getIndex());
600 aStudy = _studyService.selectStudy(kelm.getOwnerScenario()
601 .getOwnerStudy().getIndex());
602 Iterator<SimulationContext> ctxIter = aStudy
603 .SimulationContextIterator();
605 while (ctxIter.hasNext()) {
606 contexts.add(ctxIter.next());
608 Assert.assertEquals(contexts.size(), 1);
609 Assert.assertEquals(contexts.get(0), ctx);
613 filter = new KnowledgeSearchFilterDTO();
614 filter.setCreatedAfter(beforeCreation);
615 filter.setCreatedBefore(afterCreation);
616 res = _searchService.selectKnowledgeElementsWhere(filter);
617 Assert.assertNotNull(res);
618 Assert.assertEquals(res.size(), 4);
619 Assert.assertEquals(res.get(0).getTitle(), kelm11.getTitle());
620 Assert.assertEquals(res.get(1).getTitle(), kelm12.getTitle());
621 Assert.assertEquals(res.get(2).getTitle(), kelm21.getTitle());
622 Assert.assertEquals(res.get(3).getTitle(), kelm22.getTitle());
624 // Search for dates with no result
625 filter = new KnowledgeSearchFilterDTO();
626 filter.setCreatedAfter(afterCreation);
627 res = _searchService.selectKnowledgeElementsWhere(filter);
628 Assert.assertNotNull(res);
629 Assert.assertEquals(res.size(), 0);
631 rollbackNestedTransaction();
632 LOG.debug(">>>>> END testSelectKnowledgeElementsWhere()");