1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 package com.gisgraphy.domain.repository;
24
25 import java.util.ArrayList;
26 import java.util.List;
27 import java.util.Random;
28
29 import javax.annotation.Resource;
30
31 import org.junit.Test;
32 import org.springframework.beans.factory.annotation.Required;
33
34 import com.gisgraphy.domain.geoloc.entity.Adm;
35 import com.gisgraphy.domain.geoloc.entity.AlternateName;
36 import com.gisgraphy.domain.geoloc.entity.City;
37 import com.gisgraphy.domain.geoloc.entity.GisFeature;
38 import com.gisgraphy.domain.geoloc.entity.ZipCode;
39 import com.gisgraphy.domain.geoloc.importer.ImporterConfig;
40 import com.gisgraphy.domain.geoloc.service.fulltextsearch.AbstractIntegrationHttpSolrTestCase;
41 import com.gisgraphy.domain.valueobject.AlternateNameSource;
42 import com.gisgraphy.domain.valueobject.GisFeatureDistance;
43 import com.gisgraphy.test.GeolocTestHelper;
44
45 public class GisFeatureDaoTest extends AbstractIntegrationHttpSolrTestCase {
46
47 private IGisFeatureDao gisFeatureDao;
48
49 private ICityDao cityDao;
50
51 private IAdmDao admDao;
52
53 private ICountryDao countryDao;
54
55 private IAlternateNameDao alternateNameDao;
56
57 @Resource
58 private GeolocTestHelper geolocTestHelper;
59
60
61
62
63
64 @Test
65 public void testRemoveWithNullShouldThrows() {
66 try {
67 this.gisFeatureDao.remove(null);
68 fail();
69 } catch (IllegalArgumentException e) {
70 }
71 }
72
73 @Test
74 public void testRemoveACityWithGisFeatureDaoShouldRemoveTheCityAndTheInheritedGisFeature() {
75
76
77
78 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
79 null, null, new Random().nextLong());
80 City paris = new City(gisFeature);
81
82 City savedParis = this.cityDao.save(paris);
83
84 Long id = savedParis.getId();
85 City retrievedParis = this.cityDao.get(savedParis.getId());
86 assertNotNull(retrievedParis);
87 assertEquals(paris.getId(), retrievedParis.getId());
88
89
90 this.gisFeatureDao.remove(retrievedParis);
91
92
93 City retrievedParisafterRemove = this.cityDao.get(id);
94 assertEquals(null, retrievedParisafterRemove);
95
96
97 GisFeature savedGisFeatureafterRemove = this.gisFeatureDao.get(id);
98 assertNull(savedGisFeatureafterRemove);
99 }
100
101 @Test
102 public void testRemoveACityCastInGisFeatureWithGisFeatureDaoShouldREmoveTheCity() {
103 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
104 null, null, new Random().nextLong());
105 City paris = new City(gisFeature);
106
107
108 City savedParis = this.cityDao.save(paris);
109
110
111 Long id = savedParis.getId();
112 City retrievedParis = this.cityDao.get(savedParis.getId());
113 assertNotNull(retrievedParis);
114 assertEquals(paris.getId(), retrievedParis.getId());
115
116
117 this.gisFeatureDao.remove((GisFeature) retrievedParis);
118
119
120
121 City retrievedParisafterRemove = this.cityDao.get(id);
122 assertEquals(null, retrievedParisafterRemove);
123
124
125 GisFeature savedGisFeatureafterRemove = this.gisFeatureDao.get(id);
126 assertNull(savedGisFeatureafterRemove);
127
128 }
129
130 @Test
131 public void testRemoveGisFeatureWhichIsAnAdm2() {
132
133 }
134
135 @Test
136 public void testDeleteAllListShouldThrowsIfListIsNull() {
137 try {
138 this.gisFeatureDao.deleteAll(null);
139 fail();
140 } catch (IllegalArgumentException e) {
141
142 }
143 }
144
145 @Test
146 public void testDeleteAllListShouldNotThrowsForAnEmptyList() {
147 try {
148 this.gisFeatureDao.deleteAll(new ArrayList<GisFeature>());
149
150 } catch (IllegalArgumentException e) {
151 fail();
152 }
153 }
154
155 @Test
156 public void testDeleteAllListShouldDeleteTheSpecifiedElements() {
157 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
158 null, null, new Random().nextLong());
159 City paris = new City(gisFeature);
160
161 GisFeature gisFeature2 = GeolocTestHelper.createCity("cityGisFeature2",
162 null, null, new Random().nextLong());
163 City paris2 = new City(gisFeature2);
164
165
166 City savedParis = this.cityDao.save(paris);
167 City savedParis2 = this.cityDao.save(paris2);
168
169
170 City retrievedParis = this.cityDao.get(savedParis.getId());
171 assertNotNull(retrievedParis);
172 assertEquals(savedParis.getId(), retrievedParis.getId());
173
174 City retrievedParis2 = this.cityDao.get(savedParis2.getId());
175 assertNotNull(retrievedParis2);
176 assertEquals(savedParis2.getId(), retrievedParis2.getId());
177
178 List<GisFeature> listToDelete = new ArrayList<GisFeature>();
179 listToDelete.add(retrievedParis);
180 this.gisFeatureDao.deleteAll(listToDelete);
181
182 List<GisFeature> stillStored = this.gisFeatureDao.getAll();
183 assertNotNull(stillStored);
184 assertEquals(1, stillStored.size());
185 assertEquals(savedParis2, stillStored.get(0));
186
187 }
188
189 @Test
190 public void testDeleteALLShouldDeleteAlltheElements() {
191 GisFeature paris = GeolocTestHelper.createGisFeature("GisFeature",
192 null, null, new Random().nextLong());
193
194 GisFeature gisFeature2 = GeolocTestHelper.createCity("cityGisFeature2",
195 null, null, new Random().nextLong());
196 City paris2 = new City(gisFeature2);
197
198
199 GisFeature savedParis = this.gisFeatureDao.save(paris);
200 City savedParis2 = this.cityDao.save(paris2);
201
202
203 GisFeature retrievedParis = this.gisFeatureDao.get(savedParis.getId());
204 assertNotNull(retrievedParis);
205 assertEquals(savedParis.getId(), retrievedParis.getId());
206
207 City retrievedParis2 = this.cityDao.get(savedParis2.getId());
208 assertNotNull(retrievedParis2);
209 assertEquals(savedParis2.getId(), retrievedParis2.getId());
210
211 assertEquals(1, this.cityDao.deleteAll());
212
213 List<City> stillStoredCity = this.cityDao.getAll();
214 assertNotNull(stillStoredCity);
215 assertEquals(0, stillStoredCity.size());
216
217 List<GisFeature> stillStoredGis = this.gisFeatureDao.getAll();
218 assertNotNull(stillStoredGis);
219 assertEquals(1, stillStoredGis.size());
220 }
221
222 @Test
223 public void testDeleteAdmShouldNotDeleteTheGisFeaturesContainedInCascade() {
224
225 Adm adm = GeolocTestHelper.createAdm("adm", "FR", "A1", "B2", "C3",
226 "D4", null, 4);
227 Adm savedAdm = this.admDao.save(adm);
228 assertNotNull(savedAdm.getId());
229
230 Adm retrievedAdm = this.admDao.get(savedAdm.getId());
231 assertEquals(savedAdm, retrievedAdm);
232 assertEquals(savedAdm.getId(), retrievedAdm.getId());
233
234
235 GisFeature gisFeature = GeolocTestHelper.createCity("paris", 1.3F, 45F,
236 null);
237 gisFeature.setAdm(retrievedAdm);
238
239
240 GisFeature savedGisFeature = gisFeatureDao.save(gisFeature);
241
242
243 GisFeature retrievedGisFeature = this.gisFeatureDao.get(savedGisFeature
244 .getId());
245 assertNotNull(retrievedGisFeature);
246 assertEquals(savedGisFeature, retrievedGisFeature);
247
248 }
249
250 @Test
251 public void testDeleteAllExceptAdmAndCountries() {
252 geolocTestHelper.createAndSaveCityWithFullAdmTreeAndCountry(3L);
253 GisFeature gisFeatureWithNullFeatureCode = GeolocTestHelper
254 .createGisFeature("gis", 3F, 4F, 4L);
255 gisFeatureDao.save(gisFeatureWithNullFeatureCode);
256 GisFeature gisFeatureWithNotNullFeatureCode = GeolocTestHelper
257 .createGisFeature("gis", 3F, 4F, 5L);
258 gisFeatureWithNotNullFeatureCode.setFeatureClass("A");
259 gisFeatureWithNotNullFeatureCode.setFeatureCode("B");
260 gisFeatureDao.save(gisFeatureWithNotNullFeatureCode);
261
262 assertEquals(1, countryDao.count());
263 assertEquals(7, gisFeatureDao.count());
264
265 assertEquals(3, gisFeatureDao.deleteAllExceptAdmsAndCountries());
266 assertEquals(3, admDao.count());
267 assertEquals(1, countryDao.count());
268
269 assertEquals(4, gisFeatureDao.count());
270 assertEquals(1, countryDao.count());
271 assertEquals(0, cityDao.count());
272
273 }
274
275
276
277
278
279 @Test
280 public void testSaveCityCastInGisFeatureShouldSaveTheCity() {
281 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
282 null, null, new Random().nextLong());
283 City paris = new City(gisFeature);
284
285 GisFeature savedParis = this.gisFeatureDao.save((GisFeature) paris);
286
287 savedParis.getId();
288 City retrievedParis = this.cityDao.get(savedParis.getId());
289 assertNotNull(retrievedParis);
290 assertEquals(paris.getId(), retrievedParis.getId());
291 }
292
293 @Test
294 public void testSaveWithNullShouldThrows() {
295 try {
296 this.gisFeatureDao.save(null);
297 fail();
298 } catch (IllegalArgumentException e) {
299 }
300 }
301
302 @Test
303 public void testSaveCityWithGisFeatureDaoShouldSaveTheCity() {
304 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
305 null, null, new Random().nextLong());
306 City paris = new City(gisFeature);
307
308 GisFeature savedParis = this.gisFeatureDao.save(paris);
309
310 City retrievedParis = this.cityDao.get(savedParis.getId());
311 assertNotNull(retrievedParis);
312 assertEquals(paris.getId(), retrievedParis.getId());
313 }
314
315 @Test
316 public void testSaveShouldSaveTheAlternateNamesInCascade() {
317 int nbalternateNames = 3;
318 GisFeature gisFeature = GeolocTestHelper
319 .createGisFeatureWithAlternateNames("paris", nbalternateNames);
320 assertNotNull(gisFeature.getAlternateNames());
321 assertEquals(3, gisFeature.getAlternateNames().size());
322 GisFeature saved = this.gisFeatureDao.save(gisFeature);
323 GisFeature retrieved = this.gisFeatureDao.get(saved.getId());
324 assertNotNull(retrieved);
325 assertEquals(gisFeature.getId(), retrieved.getId());
326 assertNotNull(retrieved.getAlternateNames());
327 assertEquals(nbalternateNames, retrieved.getAlternateNames().size());
328 }
329
330
331
332 @Test
333 public void testgetNearestAndDistanceFromGisFeatureShouldTakeTheSpecifiedClassIntoAccount() {
334 City p1 = GeolocTestHelper.createCity("paris", 48.86667F, 2.3333F, 1L);
335 City p2 = GeolocTestHelper.createCity("bordeaux", 44.83333F, -0.56667F,
336 3L);
337 City p3 = GeolocTestHelper.createCity("goussainville", 49.01667F,
338 2.46667F, 2L);
339
340 this.cityDao.save(p1);
341 this.cityDao.save(p2);
342 this.cityDao.save(p3);
343
344 List<GisFeatureDistance> results = this.gisFeatureDao
345 .getNearestAndDistanceFromGisFeature(p1, 1000000,
346 GisFeature.class);
347 assertEquals(2, results.size());
348
349 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
350 1000000, City.class);
351 assertEquals(2, results.size());
352
353 GisFeature p4 = GeolocTestHelper.createGisFeature("test", 49.01668F,
354 2.46667F, 4L);
355 this.gisFeatureDao.save(p4);
356
357 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
358 1000000, GisFeature.class);
359 assertEquals(3, results.size());
360
361 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
362 1000000, City.class);
363 assertEquals(2, results.size());
364
365 }
366
367 @Test
368 public void testgetNearestAndDistanceFromGisFeatureShouldThrowsIfGisFeatureIsNull() {
369
370 try {
371 this.gisFeatureDao.getNearestAndDistanceFromGisFeature(null,
372 1000000, GisFeature.class);
373 fail("getNearestAndDistanceFromGisFeature should throws if gisFeature is null");
374 } catch (IllegalArgumentException e) {
375
376 }
377
378 }
379
380 @Test
381 public void testgetNearestAndDistanceFromGisFeatureShouldPaginate() {
382 City p1 = GeolocTestHelper.createCity("paris", 48.86667F, 2.3333F, 1L);
383 City p2 = GeolocTestHelper.createCity("bordeaux", 44.83333F, -0.56667F,
384 3L);
385 City p3 = GeolocTestHelper.createCity("goussainville", 49.01667F,
386 2.46667F, 2L);
387
388 this.gisFeatureDao.save(p1);
389 this.gisFeatureDao.save(p2);
390 this.gisFeatureDao.save(p3);
391
392 List<GisFeatureDistance> results = this.gisFeatureDao
393 .getNearestAndDistanceFromGisFeature(p1, 1000000, 1, 5);
394 assertEquals(2, results.size());
395 assertEquals(p3.getName(), results.get(0).getName());
396 assertEquals(p2.getName(), results.get(1).getName());
397
398 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
399 1000000, 2, 5, City.class);
400 assertEquals(1, results.size());
401 assertEquals(p2.getName(), results.get(0).getName());
402
403 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
404 1000000, 1, 1, City.class);
405 assertEquals(1, results.size());
406 assertEquals(p3.getName(), results.get(0).getName());
407
408 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
409 1000000, 0, 1, City.class);
410 assertEquals(1, results.size());
411 assertEquals(p3.getName(), results.get(0).getName());
412
413 results = this.gisFeatureDao.getNearestAndDistanceFromGisFeature(p1,
414 1000000, 1, 0, City.class);
415 assertEquals(2, results.size());
416 assertEquals(p3.getName(), results.get(0).getName());
417 assertEquals(p2.getName(), results.get(1).getName());
418
419 }
420
421 @Test
422 public void testgetNearestAndDistanceFromShouldTakeTheSpecifiedClassIntoAccount() {
423 City p1 = GeolocTestHelper.createCity("paris", 48.86667F, 2.3333F, 1L);
424 City p2 = GeolocTestHelper.createCity("bordeaux", 44.83333F, -0.56667F,
425 3L);
426 City p3 = GeolocTestHelper.createCity("goussainville", 49.01667F,
427 2.46667F, 2L);
428
429 this.cityDao.save(p1);
430 this.cityDao.save(p2);
431 this.cityDao.save(p3);
432
433 List<GisFeatureDistance> results = this.gisFeatureDao
434 .getNearestAndDistanceFrom(p1.getLocation(), 1000000,
435 GisFeature.class);
436 assertEquals(3, results.size());
437
438 results = this.gisFeatureDao.getNearestAndDistanceFrom(
439 p1.getLocation(), 1000000, City.class);
440 assertEquals(3, results.size());
441
442 GisFeature p4 = GeolocTestHelper.createGisFeature("test", 49.01668F,
443 2.46667F, 4L);
444 this.gisFeatureDao.save(p4);
445
446 results = this.gisFeatureDao.getNearestAndDistanceFrom(
447 p1.getLocation(), 1000000, GisFeature.class);
448 assertEquals(4, results.size());
449
450 results = this.gisFeatureDao.getNearestAndDistanceFrom(
451 p1.getLocation(), 1000000, City.class);
452 assertEquals(3, results.size());
453
454 }
455
456 @Test
457 public void testgetNearestAndDistanceFromShouldPaginate() {
458 City p1 = GeolocTestHelper.createCity("paris", 48.86667F, 2.3333F, 1L);
459 City p2 = GeolocTestHelper.createCity("bordeaux", 44.83333F, -0.56667F,
460 3L);
461 City p3 = GeolocTestHelper.createCity("goussainville", 49.01667F,
462 2.46667F, 2L);
463
464 this.gisFeatureDao.save(p1);
465 this.gisFeatureDao.save(p2);
466 this.gisFeatureDao.save(p3);
467
468 List<GisFeatureDistance> results = this.gisFeatureDao
469 .getNearestAndDistanceFrom(p1.getLocation(), 1000000, 1, 5);
470 assertEquals(3, results.size());
471 assertEquals(p1.getName(), results.get(0).getName());
472 assertEquals(p3.getName(), results.get(1).getName());
473 assertEquals(p2.getName(), results.get(2).getName());
474
475 results = this.gisFeatureDao.getNearestAndDistanceFrom(
476 p1.getLocation(), 1000000, 2, 5, City.class);
477 assertEquals(2, results.size());
478 assertEquals(p3.getName(), results.get(0).getName());
479 assertEquals(p2.getName(), results.get(1).getName());
480
481 results = this.gisFeatureDao.getNearestAndDistanceFrom(
482 p1.getLocation(), 1000000, 1, 1, City.class);
483 assertEquals(1, results.size());
484 assertEquals(p1.getName(), results.get(0).getName());
485
486 results = this.gisFeatureDao.getNearestAndDistanceFrom(
487 p1.getLocation(), 1000000, 0, 1, City.class);
488 assertEquals(1, results.size());
489 assertEquals(p1.getName(), results.get(0).getName());
490
491 results = this.gisFeatureDao.getNearestAndDistanceFrom(
492 p1.getLocation(), 1000000, 1, 0, City.class);
493 assertEquals(3, results.size());
494 assertEquals(p1.getName(), results.get(0).getName());
495 assertEquals(p3.getName(), results.get(1).getName());
496 assertEquals(p2.getName(), results.get(2).getName());
497
498 }
499
500 @Test
501 public void testGetEagerShouldLoadAlternateNamesAndAdm() {
502 Long featureId = 1001L;
503 City gisFeature = GeolocTestHelper.createCity("Saint-André", 1.5F, 2F,
504 featureId);
505 AlternateName alternateName = new AlternateName();
506 alternateName.setName("alteré");
507 alternateName.setGisFeature(gisFeature);
508 alternateName.setSource(AlternateNameSource.ALTERNATENAMES_FILE);
509 gisFeature.addAlternateName(alternateName);
510 City paris = new City(gisFeature);
511 paris.addZipCode(new ZipCode("50263"));
512
513 Adm admParent = GeolocTestHelper.createAdm("admparent", "FR", "A1",
514 "B2", "C3", null, null, 3);
515
516 Adm p = this.admDao.save(admParent);
517 paris.setAdm(p);
518
519 this.cityDao.save(paris);
520 this.cityDao.flushAndClear();
521 this.admDao.flushAndClear();
522
523 City retrieved = this.cityDao.get(paris.getId());
524 this.cityDao.flushAndClear();
525 this.admDao.flushAndClear();
526 try {
527 assertEquals(1, retrieved.getAlternateNames().size());
528 fail("without eager mode, getAlternateNames should throw");
529 } catch (RuntimeException e) {
530
531 }
532 try {
533 assertEquals("C3", retrieved.getAdm().getAdm3Code());
534 fail("without eager mode, getAdm should throw");
535 } catch (RuntimeException e) {
536 }
537
538 retrieved = this.cityDao.getEager(paris.getId());
539 this.cityDao.flushAndClear();
540 this.admDao.flushAndClear();
541 try {
542 assertEquals(1, retrieved.getAlternateNames().size());
543 } catch (RuntimeException e) {
544 fail("with eager mode, getAlternateNames should not throw");
545 }
546 try {
547 assertEquals("C3", retrieved.getAdm().getAdm3Code());
548 } catch (RuntimeException e) {
549 fail("with eager mode, getAdm should not throw");
550 }
551 }
552
553 @Test
554 public void testlistAllFeaturesFromTextShouldReturnResults() {
555 City city = GeolocTestHelper.createCityAtSpecificPoint("sèvres", 1.5F,
556 1.6F);
557 city.setFeatureId(3L);
558 this.gisFeatureDao.save(city);
559 this.solRSynchroniser.commit();
560 this.solRSynchroniser.optimize();
561
562 List<GisFeature> results = this.gisFeatureDao.listAllFeaturesFromText(
563 "sèvres", true);
564 assertNotNull("The fulltext search engine should not return null",
565 results);
566 assertTrue("size should be 1 but is " + results.size(),
567 results.size() == 1);
568 assertEquals(
569 "The fulltext search engine does not return the expected result",
570 new Long(3), results.get(0).getFeatureId());
571
572 }
573
574 @Test
575 public void testGetShouldThrowsIfIdIsNull() {
576 try {
577 this.gisFeatureDao.get(null);
578 fail();
579 } catch (IllegalArgumentException e) {
580 }
581 }
582
583 @Test
584 public void testExistShouldThrowsIfIdIsNull() {
585 try {
586 this.gisFeatureDao.exists(null);
587 fail();
588 } catch (IllegalArgumentException e) {
589 }
590 }
591
592 @Test
593 public void testGetAllPaginateShouldNeverReturnNull() {
594 assertNotNull(this.gisFeatureDao.getAllPaginate(1, 5));
595 }
596
597 @Test
598 public void testGetByFeatureIdShouldRetrieveTheCorrectGisfeature() {
599 Long featureId = 1001L;
600 GisFeature gisFeature = GeolocTestHelper.createCity("gisfeatureName",
601 null, null, featureId);
602 GisFeature savedGisFeature = this.gisFeatureDao.save(gisFeature);
603 GisFeature retrievedGisFeature = this.gisFeatureDao
604 .getByFeatureId(featureId);
605 assertNotNull(retrievedGisFeature);
606 assertEquals(retrievedGisFeature.getId(), savedGisFeature.getId());
607 assertEquals(retrievedGisFeature, savedGisFeature);
608 }
609
610 @Test
611 public void testGetByFeatureIdShouldRetrieveACityIfTheGisfeatureIsAcity() {
612 Long featureId = 1001L;
613 GisFeature gisFeature = GeolocTestHelper.createCity("cityGisFeature",
614 null, null, featureId);
615 City paris = new City(gisFeature);
616
617 this.gisFeatureDao.save(paris);
618
619
620 GisFeature retrievedParis = this.gisFeatureDao
621 .getByFeatureId(featureId);
622 assertNotNull(retrievedParis);
623 assertEquals(paris.getId(), retrievedParis.getId());
624 assertEquals(City.class, retrievedParis.getClass());
625
626 }
627
628 @Test
629 public void testgetDirtyShouldRetieveDirtyGisFeature() {
630
631 GisFeature gisFeature1 = GeolocTestHelper
632 .createGisFeatureWithAlternateNames("paris", 3);
633 GisFeature gisFeature2 = GeolocTestHelper
634 .createGisFeatureWithAlternateNames("paris2", 3);
635 GisFeature gisFeature3 = GeolocTestHelper
636 .createGisFeatureWithAlternateNames("paris3", 3);
637 GisFeature gisFeature4 = GeolocTestHelper
638 .createGisFeatureWithAlternateNames("paris4", 3);
639 gisFeature2.setFeatureCode(ImporterConfig.DEFAULT_FEATURE_CODE);
640 gisFeature4.setFeatureClass(ImporterConfig.DEFAULT_FEATURE_CLASS);
641 gisFeature3.setLocation(GeolocTestHelper.createPoint(0F, 0F));
642
643
644 this.gisFeatureDao.save(gisFeature1);
645 this.gisFeatureDao.save(gisFeature2);
646 this.gisFeatureDao.save(gisFeature3);
647 this.gisFeatureDao.save(gisFeature4);
648
649
650 List<GisFeature> gisFeatures = this.gisFeatureDao.getAll();
651 assertNotNull(gisFeatures);
652 assertEquals(4, gisFeatures.size());
653
654 List<GisFeature> dirties = this.gisFeatureDao.getDirties();
655 assertNotNull(dirties);
656 assertEquals(3, dirties.size());
657
658
659 }
660
661 @Test
662 public void testgetDirtyShouldNeverReturnNull() {
663 assertNotNull(this.gisFeatureDao.getDirties());
664 }
665
666 public void testGetByFeatureIdsShouldReturnTheGisFeature() {
667 City city1 = GeolocTestHelper.createCity("cityGisFeature", null, null,
668 100L);
669 City city2 = GeolocTestHelper.createCity("cityGisFeature", null, null,
670 200L);
671 GisFeature gisFeature = GeolocTestHelper
672 .createGisFeatureWithAlternateNames("gisfeature", 0);
673 gisFeature.setFeatureId(300L);
674 GisFeature gisFeature2 = GeolocTestHelper
675 .createGisFeatureWithAlternateNames("gisfeature", 0);
676 gisFeature2.setFeatureId(400L);
677
678 this.gisFeatureDao.save(city1);
679 this.gisFeatureDao.save(city2);
680 this.gisFeatureDao.save(gisFeature);
681 this.gisFeatureDao.save(gisFeature2);
682
683
684 List<GisFeature> gisFeatures = this.gisFeatureDao.getAll();
685 assertNotNull(gisFeatures);
686 assertEquals(4, gisFeatures.size());
687
688 List<Long> ids = new ArrayList<Long>();
689 ids.add(100L);
690 ids.add(200L);
691 ids.add(300L);
692 List<GisFeature> gisByIds = this.gisFeatureDao.listByFeatureIds(ids);
693 assertNotNull(gisByIds);
694 assertEquals(3, gisByIds.size());
695
696 }
697
698 @Test
699 public void testGetByFeatureIdsWithANullListOrEmptyListShouldReturnEmptylist() {
700
701 List<GisFeature> results = this.gisFeatureDao.listByFeatureIds(null);
702 assertNotNull(results);
703 assertEquals(0, results.size());
704
705
706 results = this.gisFeatureDao.listByFeatureIds(new ArrayList<Long>());
707 assertNotNull(results);
708 assertEquals(0, results.size());
709
710 }
711
712 @Test
713 public void testGetByFeatureIdWithANullFeatureIdShouldThrows() {
714 try {
715 this.gisFeatureDao.getByFeatureId(null);
716 fail();
717 } catch (IllegalArgumentException e) {
718 }
719
720 }
721
722 @Test
723 public void testSetFlushModeWithNullShouldThrows() {
724 try {
725 this.gisFeatureDao.setFlushMode(null);
726 fail();
727 } catch (RuntimeException e) {
728 }
729 }
730
731 @Test
732 public void testGetAllShouldNotReturnNull() {
733 assertNotNull(gisFeatureDao.getAll());
734 }
735
736 @Test
737 public void testListByNameShouldNotReturnNullButAnEmptyList() {
738 assertNotNull(gisFeatureDao.listByName("ABC"));
739 }
740
741 @Test
742 public void testListByNameWithNullNameShouldThrows() {
743 try {
744 assertNotNull(gisFeatureDao.listByName(null));
745 fail();
746 } catch (IllegalArgumentException e) {
747 }
748 }
749
750 public void testListFromTextShouldOnlyReturnFeaturesOfTheSpecifiedClass() {
751
752 Long featureId = 1001L;
753 GisFeature gisFeature = GeolocTestHelper.createCity("Saint-André",
754 1.5F, 2F, featureId);
755 AlternateName alternateName = new AlternateName();
756 alternateName.setName("alteré");
757 alternateName.setGisFeature(gisFeature);
758 alternateName.setSource(AlternateNameSource.ALTERNATENAMES_FILE);
759 gisFeature.addAlternateName(alternateName);
760 City paris = new City(gisFeature);
761 paris.addZipCode(new ZipCode("50263"));
762
763
764 GisFeature gisAdm = GeolocTestHelper.createGisFeatureForAdm(
765 "Saint-andré", 2.5F, 3.5F, 40L, 4);
766 Adm adm = GeolocTestHelper.createAdm("Saint-André", "FR", "A1", "B2",
767 "C3", "D4", gisAdm, 4);
768
769
770 Long featureId2 = 1002L;
771 GisFeature gisFeature2 = GeolocTestHelper.createCity("mytown", 1.5F,
772 2F, featureId2);
773 City paris2 = new City(gisFeature2);
774 paris2.addZipCode(new ZipCode("50264"));
775
776
777 this.gisFeatureDao.save(paris);
778 assertNotNull(this.gisFeatureDao.getByFeatureId(featureId));
779 this.gisFeatureDao.save(paris2);
780 assertNotNull(this.gisFeatureDao.getByFeatureId(featureId2));
781
782
783 this.admDao.save(adm);
784 assertTrue(this.admDao.getAll().size() == 1);
785
786
787 assertEquals(1, alternateNameDao.getAll().size());
788
789
790 this.solRSynchroniser.commit();
791
792
793 List<City> results = this.cityDao.listFromText("Saint-André", false);
794 assertTrue(
795 "There must only have one results and only one (the city one), the adm should not be retrieved an nor the second city",
796 results.size() == 1);
797 assertEquals("Saint-André", results.get(0).getName());
798 assertTrue(results.get(0).getFeatureId() == featureId);
799
800
801 results = this.cityDao.listFromText("st-André", false);
802 assertTrue("The synonyms with st/saint/santa should be returned",
803 results.size() == 1);
804 assertEquals("Saint-André", results.get(0).getName());
805 assertTrue(results.get(0).getFeatureId() == featureId);
806
807 results = this.cityDao.listFromText("St-André", false);
808 assertTrue("The synonyms must be case insensitive", results.size() == 1);
809 assertEquals("Saint-André", results.get(0).getName());
810 assertTrue(results.get(0).getFeatureId() == featureId);
811
812 List<GisFeature> resultsGis = this.gisFeatureDao.listFromText(
813 "Saint-André", false);
814 assertTrue(
815 "Even if gisFeature is a city, no gisFeature should be retrieved",
816 resultsGis.size() == 0);
817
818
819 List<Adm> resultsAdm = this.admDao.listFromText("Saint-André", false);
820 assertTrue("an Adm should be retrieved for Saint-André", resultsAdm
821 .size() == 1);
822 assertTrue(resultsAdm.get(0).getFeatureId() == 40L);
823
824
825 List<Adm> noResults = this.admDao.listFromText("test", true);
826 assertTrue("no Adm should be found for 'test'", noResults.size() == 0);
827 List<GisFeature> noResults2 = this.gisFeatureDao.listFromText("test",
828 true);
829 assertTrue("no GisFeature should be found for 'test'", noResults2
830 .size() == 0);
831 List<City> noResults3 = this.cityDao.listFromText("test", true);
832 assertTrue("no city should be found for 'test'", noResults3.size() == 0);
833
834
835 List<Adm> zipResults = this.admDao.listFromText("50264", true);
836 assertTrue("no Adm should be found for '50264'", zipResults.size() == 0);
837 List<GisFeature> zipResults2 = this.gisFeatureDao.listFromText("50264",
838 true);
839 assertTrue("no GisFeature should be found for '50264'", zipResults2
840 .size() == 0);
841 List<City> zipResults3 = this.cityDao.listFromText("50264", true);
842 assertTrue("a city should be found for '50264' in alternatenames",
843 zipResults3.size() == 1);
844 List<City> zipResults4 = this.cityDao.listFromText("50264", false);
845 assertTrue("a city should be found for '50264' in zipcode", zipResults4
846 .size() == 1);
847
848
849 results = this.cityDao.listFromText("alteré", false);
850 assertTrue("alternateName should not be included", results.size() == 0);
851 results = this.cityDao.listFromText("alteré", true);
852 assertTrue("alternateName should be included", results.size() == 1);
853 assertEquals("Saint-André", results.get(0).getName());
854 assertTrue(results.get(0).getFeatureId() == featureId);
855
856
857 results = this.cityDao.listFromText("Saint André", false);
858 assertTrue(
859 "the fulltext search engine should be iso, case and - insensitive",
860 results.size() == 1);
861
862 results = this.cityDao.listFromText("saInt andré", false);
863 assertTrue(
864 "the fulltext search engine should be iso, case and - insensitive",
865 results.size() == 1);
866
867 results = this.cityDao.listFromText("saInt andre", false);
868 assertTrue(
869 "the fulltext search engine should be iso, case and - insensitive",
870 results.size() == 1);
871 }
872
873 public void testCreateGISTIndexForLocationColumnShouldNotThrow(){
874 gisFeatureDao.createGISTIndexForLocationColumn();
875 }
876
877 @Required
878 public void setGisFeatureDao(IGisFeatureDao gisFeatureDao) {
879 this.gisFeatureDao = gisFeatureDao;
880 }
881
882 @Required
883 public void setCityDao(ICityDao cityDao) {
884 this.cityDao = cityDao;
885 }
886
887 @Required
888 public void setAdmDao(IAdmDao admDao) {
889 this.admDao = admDao;
890 }
891
892 @Required
893 public void setAlternateNameDao(IAlternateNameDao alternateNameDao) {
894 this.alternateNameDao = alternateNameDao;
895 }
896
897
898
899
900
901 @Required
902 public void setCountryDao(ICountryDao countryDao) {
903 this.countryDao = countryDao;
904 }
905
906 }