2 * Copyright (C) 2009 EDIT
3 * European Distributed Institute of Taxonomy
4 * http://www.e-taxonomy.eu
6 * The contents of this file are subject to the Mozilla Public License Version 1.1
7 * See LICENSE.TXT at the top of this package for the full license terms.
9 package eu
.etaxonomy
.cdm
.api
.service
;
11 import static org
.junit
.Assert
.assertEquals
;
12 import static org
.junit
.Assert
.assertNotNull
;
13 import static org
.junit
.Assert
.assertNull
;
14 import static org
.junit
.Assert
.assertTrue
;
16 import java
.io
.FileNotFoundException
;
17 import java
.util
.ArrayList
;
18 import java
.util
.Iterator
;
19 import java
.util
.List
;
21 import java
.util
.UUID
;
23 import org
.apache
.log4j
.Logger
;
24 import org
.junit
.Assert
;
25 import org
.junit
.Test
;
26 import org
.unitils
.dbunit
.annotation
.DataSet
;
27 import org
.unitils
.spring
.annotation
.SpringBeanByType
;
29 import eu
.etaxonomy
.cdm
.api
.service
.config
.IdentifiableServiceConfiguratorImpl
;
30 import eu
.etaxonomy
.cdm
.api
.service
.config
.IncludedTaxonConfiguration
;
31 import eu
.etaxonomy
.cdm
.api
.service
.config
.MatchingTaxonConfigurator
;
32 import eu
.etaxonomy
.cdm
.api
.service
.config
.NameDeletionConfigurator
;
33 import eu
.etaxonomy
.cdm
.api
.service
.config
.NodeDeletionConfigurator
.ChildHandling
;
34 import eu
.etaxonomy
.cdm
.api
.service
.config
.SynonymDeletionConfigurator
;
35 import eu
.etaxonomy
.cdm
.api
.service
.config
.TaxonDeletionConfigurator
;
36 import eu
.etaxonomy
.cdm
.api
.service
.dto
.IncludedTaxaDTO
;
37 import eu
.etaxonomy
.cdm
.api
.service
.exception
.HomotypicalGroupChangeException
;
38 import eu
.etaxonomy
.cdm
.api
.service
.pager
.Pager
;
39 import eu
.etaxonomy
.cdm
.model
.agent
.Person
;
40 import eu
.etaxonomy
.cdm
.model
.common
.Annotation
;
41 import eu
.etaxonomy
.cdm
.model
.common
.CdmBase
;
42 import eu
.etaxonomy
.cdm
.model
.common
.IdentifiableSource
;
43 import eu
.etaxonomy
.cdm
.model
.common
.Language
;
44 import eu
.etaxonomy
.cdm
.model
.common
.LanguageString
;
45 import eu
.etaxonomy
.cdm
.model
.common
.Marker
;
46 import eu
.etaxonomy
.cdm
.model
.common
.MarkerType
;
47 import eu
.etaxonomy
.cdm
.model
.description
.CommonTaxonName
;
48 import eu
.etaxonomy
.cdm
.model
.description
.DescriptionElementBase
;
49 import eu
.etaxonomy
.cdm
.model
.description
.IndividualsAssociation
;
50 import eu
.etaxonomy
.cdm
.model
.description
.TaxonDescription
;
51 import eu
.etaxonomy
.cdm
.model
.description
.TextData
;
52 import eu
.etaxonomy
.cdm
.model
.metadata
.SecReferenceHandlingEnum
;
53 import eu
.etaxonomy
.cdm
.model
.name
.HomotypicalGroup
;
54 import eu
.etaxonomy
.cdm
.model
.name
.IBotanicalName
;
55 import eu
.etaxonomy
.cdm
.model
.name
.INonViralName
;
56 import eu
.etaxonomy
.cdm
.model
.name
.NameRelationship
;
57 import eu
.etaxonomy
.cdm
.model
.name
.NameRelationshipType
;
58 import eu
.etaxonomy
.cdm
.model
.name
.NomenclaturalCode
;
59 import eu
.etaxonomy
.cdm
.model
.name
.Rank
;
60 import eu
.etaxonomy
.cdm
.model
.name
.SpecimenTypeDesignation
;
61 import eu
.etaxonomy
.cdm
.model
.name
.TaxonName
;
62 import eu
.etaxonomy
.cdm
.model
.name
.TaxonNameFactory
;
63 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivationEvent
;
64 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivationEventType
;
65 import eu
.etaxonomy
.cdm
.model
.occurrence
.DerivedUnit
;
66 import eu
.etaxonomy
.cdm
.model
.occurrence
.DeterminationEvent
;
67 import eu
.etaxonomy
.cdm
.model
.occurrence
.FieldUnit
;
68 import eu
.etaxonomy
.cdm
.model
.occurrence
.SpecimenOrObservationBase
;
69 import eu
.etaxonomy
.cdm
.model
.occurrence
.SpecimenOrObservationType
;
70 import eu
.etaxonomy
.cdm
.model
.reference
.OriginalSourceType
;
71 import eu
.etaxonomy
.cdm
.model
.reference
.Reference
;
72 import eu
.etaxonomy
.cdm
.model
.reference
.ReferenceFactory
;
73 import eu
.etaxonomy
.cdm
.model
.taxon
.Classification
;
74 import eu
.etaxonomy
.cdm
.model
.taxon
.Synonym
;
75 import eu
.etaxonomy
.cdm
.model
.taxon
.SynonymType
;
76 import eu
.etaxonomy
.cdm
.model
.taxon
.Taxon
;
77 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonBase
;
78 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonNode
;
79 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationship
;
80 import eu
.etaxonomy
.cdm
.model
.taxon
.TaxonRelationshipType
;
81 import eu
.etaxonomy
.cdm
.strategy
.cache
.common
.IIdentifiableEntityCacheStrategy
;
82 import eu
.etaxonomy
.cdm
.test
.integration
.CdmTransactionalIntegrationTest
;
83 import eu
.etaxonomy
.cdm
.test
.unitils
.CleanSweepInsertLoadStrategy
;
88 public class TaxonServiceImplTest
extends CdmTransactionalIntegrationTest
{
90 private static final Logger logger
= Logger
.getLogger(TaxonServiceImplTest
.class);
93 private ITaxonService service
;
96 private INameService nameService
;
99 private IReferenceService referenceService
;
102 private IClassificationService classificationService
;
105 private ITaxonNodeService nodeService
;
108 private IDescriptionService descriptionService
;
111 private IMarkerService markerService
;
114 private IEventBaseService eventService
;
117 private IOccurrenceService occurenceService
;
119 private Synonym synonym
;
120 private Synonym synonym2
;
122 private Taxon taxWithSyn
;
123 private Taxon tax2WithSyn
;
124 private Taxon taxWithoutSyn
;
125 private UUID uuidSyn
;
126 private UUID uuidTaxWithoutSyn
;
127 private UUID uuidSyn2
;
128 private UUID uuidTaxWithSyn
;
130 private static String
[] genera
= {"Carex", "Abies", "Belladonna", "Dracula", "Maria", "Calendula", "Polygala", "Vincia"};
131 private static String
[] epitheta
= {"vulgaris", "magdalena", "officinalis", "alba", "negra", "communa", "alpina", "rotundifolia", "greutheriana", "helventica", "allemania", "franca"};
132 private static String
[] ranks
= {"subsp", "var", "f"};
134 public static UUID GENUS_NAME_UUID
= UUID
.fromString("8d761fc4-b509-42f4-9568-244161934336");
135 public static UUID GENUS_UUID
= UUID
.fromString("bf4298a8-1735-4353-a210-244442e1bd62");
136 public static UUID BASIONYM_UUID
= UUID
.fromString("7911c51d-ccb7-4708-8992-639eae58a0e3");
137 public static UUID SPECIES1_UUID
= UUID
.fromString("f0eb77d9-76e0-47f4-813f-9b5605b78685");
138 public static UUID SPECIES1_NAME_UUID
= UUID
.fromString("efd78713-126f-42e1-9070-a1ff83f12abf");
139 public static UUID SYNONYM_NAME_UUID
= UUID
.fromString("b9cbaa74-dbe0-4930-8050-b7754ce85dc0");
140 public static UUID SPECIES2_NAME_UUID
= UUID
.fromString("0267ab67-483e-4da5-b654-11013b242c22");
141 public static UUID SPECIES2_UUID
= UUID
.fromString("e20eb549-ced6-4e79-9d74-44f0792a4929");
142 public static UUID SYNONYM2_NAME_UUID
= UUID
.fromString("7c17c811-4201-454b-8108-7be7c91c0938");
143 public static UUID SYNONYM2_UUID
= UUID
.fromString("2520b103-bd89-4ac1-99e4-e3bfcedfd4eb");
144 public static UUID SPECIES5_NAME_UUID
= UUID
.fromString("0c6ecaac-804d-49e5-a33f-1b7ee77439e3");
146 /****************** TESTS *****************************/
150 * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.
153 public final void testGetTaxonByUuid() {
154 Taxon expectedTaxon
= Taxon
.NewInstance(null, null);
155 UUID uuid
= service
.save(expectedTaxon
).getUuid();
156 TaxonBase
<?
> actualTaxon
= service
.find(uuid
);
157 assertEquals(expectedTaxon
, actualTaxon
);
161 * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.
164 public final void testGetTaxonByTitle() {
165 TaxonName name
= TaxonName
.NewInstance(NomenclaturalCode
.ICNAFP
, Rank
.SPECIES(), "Abies", null, "alba", null, null, null, null, null);
166 Taxon expectedTaxon
= Taxon
.NewInstance(name
, null);
167 expectedTaxon
.setDoubtful(true);
168 service
.save(expectedTaxon
);
169 IdentifiableServiceConfiguratorImpl
<TaxonBase
> config
= new IdentifiableServiceConfiguratorImpl
<TaxonBase
>();
170 config
.setTitleSearchString("Abies alba*");
171 //doubtful taxa should be found
172 Pager
<TaxonBase
> actualTaxa
= service
.findByTitle(config
);
173 assertEquals(expectedTaxon
, actualTaxa
.getRecords().get(0));
175 //and other taxa as well
176 expectedTaxon
.setDoubtful(false);
177 service
.saveOrUpdate(expectedTaxon
);
178 actualTaxa
= service
.findByTitle(config
);
179 assertEquals(expectedTaxon
, actualTaxa
.getRecords().get(0));
184 * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#saveTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.
187 public final void testSaveTaxon() {
188 Taxon expectedTaxon
= Taxon
.NewInstance(null, null);
189 UUID uuid
= service
.save(expectedTaxon
).getUuid();
190 TaxonBase
<?
> actualTaxon
= service
.find(uuid
);
191 assertEquals(expectedTaxon
, actualTaxon
);
195 public final void testSaveOrUpdateTaxon() {
196 Taxon expectedTaxon
= Taxon
.NewInstance(null, null);
197 UUID uuid
= service
.save(expectedTaxon
).getUuid();
198 TaxonBase
<?
> actualTaxon
= service
.find(uuid
);
199 assertEquals(expectedTaxon
, actualTaxon
);
201 actualTaxon
.setName(TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES()));
203 service
.saveOrUpdate(actualTaxon
);
210 public final void testSaveOrUpdateTaxonWithMisappliedName() {
211 Taxon expectedTaxon
= Taxon
.NewInstance(null, null);
212 TaxonName misappliedNameName
= TaxonName
.NewInstance(NomenclaturalCode
.ICNAFP
, Rank
.SPECIES(), "Abies", null, "alba", null, null, null, null, null);
214 UUID misappliedNameNameUuid
= nameService
.save(misappliedNameName
).getUuid();
215 misappliedNameName
= nameService
.find(misappliedNameNameUuid
);
216 SpecimenTypeDesignation typedes
= SpecimenTypeDesignation
.NewInstance();
217 DerivedUnit derivedUnit
= DerivedUnit
.NewPreservedSpecimenInstance();
218 FieldUnit fieldUnit
= FieldUnit
.NewInstance();
219 DerivationEvent derivationEvent
= DerivationEvent
.NewSimpleInstance(fieldUnit
, derivedUnit
, DerivationEventType
.ACCESSIONING());
220 // derivedUnit.addDerivationEvent(derivationEvent);
221 typedes
.setTypeSpecimen(derivedUnit
);
222 misappliedNameName
.addTypeDesignation(typedes
, false);
223 Taxon misappliedName
= Taxon
.NewInstance(misappliedNameName
, null);
224 UUID misappliedNameUuid
= service
.save(misappliedName
).getUuid();
225 misappliedName
= (Taxon
) service
.find(misappliedNameUuid
);
226 expectedTaxon
.addMisappliedName(misappliedName
, null, null);
227 UUID uuid
= service
.save(expectedTaxon
).getUuid();
228 TaxonBase
<?
> actualTaxon
= service
.find(uuid
);
229 assertEquals(expectedTaxon
, actualTaxon
);
230 misappliedName
.setSec(ReferenceFactory
.newArticle());
233 service
.saveOrUpdate(actualTaxon
);
234 misappliedName
= (Taxon
)service
.find(misappliedNameUuid
);
235 Assert
.assertNotNull(misappliedName
.getSec());
239 commitAndStartNewTransaction(null);
240 actualTaxon
= service
.find(uuid
);
241 ((Taxon
)actualTaxon
).getTaxonRelations(misappliedName
).iterator().next().getFromTaxon().setSec(null);
243 service
.saveOrUpdate(actualTaxon
);
244 misappliedName
= (Taxon
)service
.find(misappliedNameUuid
);
245 Assert
.assertNull(misappliedName
.getSec());
252 * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.
255 public final void testRemoveTaxon() {
256 Taxon taxon
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.UNKNOWN_RANK()), null);
257 UUID uuid
= service
.save(taxon
).getUuid();
259 service
.deleteTaxon(taxon
.getUuid(), null, null);
260 /*} catch (DataChangeNoRollbackException e) {
261 // TODO Auto-generated catch block
264 TaxonBase
<?
> actualTaxon
= service
.find(uuid
);
265 assertNull(actualTaxon
);
270 public final void testMakeTaxonSynonym() {
273 } catch (FileNotFoundException e
) {
274 // TODO Auto-generated catch block
278 synonym
.setSec(ReferenceFactory
.newArticle());
279 service
.saveOrUpdate(synonym
);
280 UpdateResult result
= service
.swapSynonymAndAcceptedTaxon(synonym
, taxWithSyn
, true);
283 Taxon tax
= (Taxon
)service
.find(result
.getCdmEntity().getUuid());
284 MatchingTaxonConfigurator configurator
= MatchingTaxonConfigurator
.NewInstance();
285 configurator
.setTaxonNameTitle("Test3");
286 List
<TaxonBase
> synList
= service
.findTaxaByName(configurator
);
287 HomotypicalGroup groupTest2
= null;
288 if (synList
.size() > 0){
289 TaxonBase syn
= synList
.get(0);
290 groupTest2
= syn
.getHomotypicGroup();
291 assertTrue(tax
.getSynonyms().contains(syn
));
293 Assert
.fail("There should be a synonym with name Test3");
296 assertTrue(tax
.getName().getTitleCache().equals("Test2"));
300 public final void testMakeTaxonSynonymNewUuid() {
303 } catch (FileNotFoundException e
) {
304 // TODO Auto-generated catch block
308 synonym
.setSec(ReferenceFactory
.newArticle());
309 service
.saveOrUpdate(synonym
);
310 UpdateResult result
= service
.swapSynonymAndAcceptedTaxonNewUuid(synonym
, taxWithSyn
, true);
313 Taxon tax
= (Taxon
)service
.find(result
.getCdmEntity().getUuid());
314 MatchingTaxonConfigurator configurator
= MatchingTaxonConfigurator
.NewInstance();
315 configurator
.setTaxonNameTitle("Test3");
316 List
<TaxonBase
> synList
= service
.findTaxaByName(configurator
);
317 HomotypicalGroup groupTest2
= null;
318 if (synList
.size() > 0){
319 TaxonBase syn
= synList
.get(0);
320 groupTest2
= syn
.getHomotypicGroup();
321 assertTrue(tax
.getSynonyms().contains(syn
));
323 Assert
.fail("There should be a synonym with name Test3");
326 assertTrue(tax
.getName().getTitleCache().equals("Test2"));
333 public final void testChangeSynonymToAcceptedTaxon() throws FileNotFoundException
{
337 UpdateResult result
= new UpdateResult();
339 result
= service
.changeSynonymToAcceptedTaxon(synonym
, taxWithSyn
, null, null, null, true);
340 } catch (HomotypicalGroupChangeException e
) {
341 Assert
.fail("Invocation of change method should not throw an exception");
344 //test flush (resave deleted object)
345 TaxonBase
<?
> syn
= service
.find(uuidSyn
);
346 taxWithSyn
= (Taxon
)service
.find(uuidTaxWithSyn
);
347 Taxon taxNew
= (Taxon
)service
.find(result
.getCdmEntity().getUuid());
349 assertNotNull(taxWithSyn
);
350 assertNotNull(taxNew
);
352 Assert
.assertEquals("New taxon should have 1 synonym relationship (the old homotypic synonym)", 1, ((Taxon
)result
.getCdmEntity()).getSynonyms().size());
356 public final void testChangeSynonymToAcceptedTaxonWithSecHandlingAlwaysDelete(){
357 Taxon genus
= getTestTaxon();
358 TaxonNode node
= genus
.getTaxonNodes().iterator().next();
360 UpdateResult result
= new UpdateResult();
362 result
= service
.changeSynonymToAcceptedTaxon(SYNONYM2_UUID
, SPECIES2_UUID
, node
.getUuid(), null, null, SecReferenceHandlingEnum
.AlwaysDelete
, true);
363 } catch (HomotypicalGroupChangeException e
) {
364 Assert
.fail("Invocation of change method should not throw an exception");
367 //test flush (resave deleted object)
368 TaxonBase
<?
> syn
= service
.find(SYNONYM2_UUID
);
369 taxWithSyn
= (Taxon
)service
.find(SPECIES2_UUID
);
370 TaxonNode taxNodeNew
= nodeService
.find(result
.getCdmEntity().getUuid());
371 Taxon taxNew
= taxNodeNew
.getTaxon();
373 assertNotNull(taxWithSyn
);
374 assertNotNull(taxNew
);
375 assertNull(taxNew
.getSec());
381 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testMoveSynonymToAnotherTaxon.xml")
382 public final void testChangeSynonymToAcceptedTaxonWithSecHandlingAlwaysKeep(){
383 Taxon genus
= getTestTaxon();
384 TaxonNode node
= genus
.getTaxonNodes().iterator().next();
385 UpdateResult result
= new UpdateResult();
386 TaxonBase
<?
> syn
= service
.find(SYNONYM2_UUID
);
387 Reference sec
= ReferenceFactory
.newBook();
388 sec
.setTitleCache("Flora Cuba", true);
390 service
.saveOrUpdate(syn
);
392 result
= service
.changeSynonymToAcceptedTaxon(SYNONYM2_UUID
, SPECIES2_UUID
, node
.getUuid(), null, null, SecReferenceHandlingEnum
.KeepAlways
, true);
393 } catch (HomotypicalGroupChangeException e
) {
394 Assert
.fail("Invocation of change method should not throw an exception");
397 //test flush (resave deleted object)
398 syn
= service
.find(SYNONYM2_UUID
);
399 taxWithSyn
= (Taxon
)service
.find(SPECIES2_UUID
);
400 TaxonNode taxNodeNew
= nodeService
.find(result
.getCdmEntity().getUuid());
401 Taxon taxNew
= taxNodeNew
.getTaxon();
403 assertNotNull(taxWithSyn
);
404 assertNotNull(taxNew
);
405 assertNotNull(taxNew
.getSec());
406 assertEquals(sec
, taxNew
.getSec());
411 public final void testChangeSynonymToAcceptedTaxonWithSecHandlingUseNewParentSec(){
412 Taxon genus
= getTestTaxon();
413 TaxonNode node
= genus
.getTaxonNodes().iterator().next();
414 UpdateResult result
= new UpdateResult();
415 TaxonBase
<?
> syn
= service
.find(SYNONYM2_UUID
);
416 Reference sec
= ReferenceFactory
.newBook();
417 sec
.setTitleCache("Flora Cuba", true);
419 service
.saveOrUpdate(syn
);
421 result
= service
.changeSynonymToAcceptedTaxon(SYNONYM2_UUID
, SPECIES2_UUID
, node
.getUuid(), null, null, SecReferenceHandlingEnum
.UseNewParentSec
, true);
422 } catch (HomotypicalGroupChangeException e
) {
423 Assert
.fail("Invocation of change method should not throw an exception");
426 //test flush (resave deleted object)
427 syn
= service
.find(SYNONYM2_UUID
);
428 taxWithSyn
= (Taxon
)service
.find(SPECIES2_UUID
);
429 TaxonNode taxNodeNew
= nodeService
.find(result
.getCdmEntity().getUuid());
430 Taxon taxNew
= taxNodeNew
.getTaxon();
432 assertNotNull(taxWithSyn
);
433 assertNotNull(taxNew
);
434 assertNotNull(taxNew
.getSec());
435 assertEquals(taxWithSyn
.getSec(), taxNew
.getSec());
440 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testMoveSynonymToAnotherTaxon.xml")
441 public final void testChangeSynonymToAcceptedTaxonWithSecHandlingWarningSelect(){
442 Taxon genus
= getTestTaxon();
443 TaxonNode node
= genus
.getTaxonNodes().iterator().next();
445 UpdateResult result
= new UpdateResult();
446 TaxonBase
<?
> syn
= service
.find(SYNONYM2_UUID
);
447 Reference sec
= ReferenceFactory
.newBook();
448 sec
.setTitleCache("Flora Cuba", true);
449 Reference newSec
= ReferenceFactory
.newBook();
450 newSec
.setTitleCache("Flora Hawaii", true);
451 UUID newSecUuid
= referenceService
.saveOrUpdate(newSec
);
453 service
.saveOrUpdate(syn
);
455 result
= service
.changeSynonymToAcceptedTaxon(SYNONYM2_UUID
, SPECIES2_UUID
, node
.getUuid(), newSecUuid
, "23", SecReferenceHandlingEnum
.WarningSelect
, true);
456 } catch (HomotypicalGroupChangeException e
) {
457 Assert
.fail("Invocation of change method should not throw an exception");
460 //test flush (resave deleted object)
461 syn
= service
.find(SYNONYM2_UUID
);
462 taxWithSyn
= (Taxon
)service
.find(SPECIES2_UUID
);
463 TaxonNode taxNodeNew
= nodeService
.find(result
.getCdmEntity().getUuid());
464 Taxon taxNew
= taxNodeNew
.getTaxon();
466 assertNotNull(taxWithSyn
);
467 assertNotNull(taxNew
);
468 assertNotNull(taxNew
.getSec());
469 assertEquals(newSec
, taxNew
.getSec());
475 public final void testChangeSynonymToAcceptedTaxonSynonymForTwoTaxa(){
478 } catch (FileNotFoundException e1
) {
479 // TODO Auto-generated catch block
480 e1
.printStackTrace();
485 UpdateResult result
= new UpdateResult();
487 result
= service
.changeSynonymToAcceptedTaxon(synonym
, taxWithSyn
, null, null, null, true);
489 } catch (HomotypicalGroupChangeException e
) {
490 Assert
.fail("Invocation of change method should not throw an exception");
495 //test flush (resave deleted object)
496 TaxonBase
<?
> syn
= service
.find(uuidSyn
);
497 taxWithSyn
= (Taxon
)service
.find(uuidTaxWithSyn
);
498 Taxon taxNew
= (Taxon
)service
.find(((Taxon
)result
.getCdmEntity()).getUuid());
500 assertNotNull(taxWithSyn
);
501 assertNotNull(taxNew
);
503 // Assert.assertEquals("New taxon should have 1 synonym relationship (the old homotypic synonym)", 1, taxon.getSynonymRelations().size());
507 * Old implementation taken from {@link TaxonServiceImplBusinessTest} for old version of method.
510 public final void testMoveSynonymToAnotherTaxon_OLD() {
511 SynonymType heteroTypicSynonymType
= SynonymType
.HETEROTYPIC_SYNONYM_OF();
512 Reference reference
= ReferenceFactory
.newGeneric();
513 String referenceDetail
= "test";
515 INonViralName t1n
= TaxonNameFactory
.NewNonViralInstance(null);
516 Taxon t1
= Taxon
.NewInstance(t1n
, reference
);
517 INonViralName t2n
= TaxonNameFactory
.NewNonViralInstance(null);
518 Taxon t2
= Taxon
.NewInstance(t2n
, reference
);
519 INonViralName s1n
= TaxonNameFactory
.NewNonViralInstance(null);
520 Synonym s1
= Synonym
.NewInstance(s1n
, reference
);
521 t1
.addSynonym(s1
, heteroTypicSynonymType
);
522 service
.saveOrUpdate(t1
);
524 Synonym synonym
= t1
.getSynonyms().iterator().next();
526 boolean keepReference
= false;
527 boolean moveHomotypicGroup
= false;
529 service
.moveSynonymToAnotherTaxon(synonym
, t2
, moveHomotypicGroup
, heteroTypicSynonymType
, reference
.getUuid(), referenceDetail
, keepReference
);
530 } catch (HomotypicalGroupChangeException e
) {
531 Assert
.fail("Method call should not throw exception");
534 Assert
.assertTrue("t1 should have no synonyms", t1
.getSynonyms().isEmpty());
536 Set
<Synonym
> synonyms
= t2
.getSynonyms();
537 Assert
.assertTrue("t2 should have exactly one synonym", synonyms
.size() == 1);
539 synonym
= synonyms
.iterator().next();
541 Assert
.assertEquals(t2
, synonym
.getAcceptedTaxon());
542 Assert
.assertEquals(heteroTypicSynonymType
, synonym
.getType());
543 Assert
.assertEquals(reference
, synonym
.getSec());
544 Assert
.assertEquals(referenceDetail
, synonym
.getSecMicroReference());
548 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testMoveSynonymToAnotherTaxon.xml")
549 public final void testMoveSynonymToAnotherTaxon() throws Exception
{
550 final String
[] tableNames
= new String
[]{};
552 // printDataSet(System.err, new String[]{"AgentBase", "TaxonBase"});
553 // printDataSet(System.err, new String[]{"TaxonNode"});
555 UUID uuidNewTaxon
= UUID
.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");
556 UUID uuidOldTaxon
= UUID
.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
557 UUID uuidSyn1
= UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
558 UUID uuidSyn3
= UUID
.fromString("3fba2b22-22ae-4291-af67-faab748a5232");
559 UUID uuidSyn4
= UUID
.fromString("f9b589c7-50cf-4df2-a52e-1b85eb7e4805");
560 UUID uuidSyn5
= UUID
.fromString("fcc0bcf8-8bac-43bd-9508-1e97821587dd");
561 UUID uuidSyn6
= UUID
.fromString("0ccd4e7c-6fbd-4b7c-bd47-29e45b92f34b");
562 UUID uuidRef1
= UUID
.fromString("336f9b38-698c-45d7-be7b-993ed3355bdc");
563 UUID uuidRef2
= UUID
.fromString("c8f49d1a-69e1-48a3-98bb-45d61f3da3e7");
566 boolean moveHomotypicGroup
= true;
567 SynonymType newSynonymType
= null;
568 boolean keepReference
= true;
569 Reference newReference
= null;
570 String newReferenceDetail
= null;
572 Taxon newTaxon
= (Taxon
)service
.load(uuidNewTaxon
);
573 Synonym homotypicSynonym
= (Synonym
)service
.load(uuidSyn1
);
574 Assert
.assertNotNull("Synonym should exist", homotypicSynonym
);
575 Assert
.assertNotNull("Synonym should have 1 relation", homotypicSynonym
.getAcceptedTaxon());
576 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon
, homotypicSynonym
.getAcceptedTaxon().getUuid());
577 Taxon oldTaxon
= homotypicSynonym
.getAcceptedTaxon();
580 service
.moveSynonymToAnotherTaxon(homotypicSynonym
, newTaxon
, moveHomotypicGroup
, newSynonymType
, null, newReferenceDetail
, keepReference
);
581 Assert
.fail("Homotypic synonym move to other taxon should throw an exception");
582 } catch (HomotypicalGroupChangeException e
) {
583 if (e
.getMessage().contains("Synonym is in homotypic group with accepted taxon and other synonym(s). First remove synonym from homotypic group of accepted taxon before moving to other taxon")){
585 commitAndStartNewTransaction(tableNames
);
587 Assert
.fail("Unexpected exception occurred: " + e
.getMessage());
591 homotypicSynonym
= (Synonym
)service
.load(uuidSyn1
);
592 Assert
.assertNotNull("Synonym should still exist", homotypicSynonym
);
593 Assert
.assertNotNull("Synonym should still have 1 relation", homotypicSynonym
.getAcceptedTaxon());
594 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", oldTaxon
, homotypicSynonym
.getAcceptedTaxon());
596 //test heterotypic synonym with other synonym in homotypic group
597 newTaxon
= (Taxon
)service
.load(uuidNewTaxon
);
598 Synonym heterotypicSynonym
= (Synonym
)service
.load(uuidSyn3
);
599 Assert
.assertNotNull("Synonym should exist", heterotypicSynonym
);
600 Assert
.assertNotNull("Synonym should have 1 relation", heterotypicSynonym
.getAcceptedTaxon());
601 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon
, heterotypicSynonym
.getAcceptedTaxon().getUuid());
602 oldTaxon
= heterotypicSynonym
.getAcceptedTaxon();
603 moveHomotypicGroup
= false;
606 service
.moveSynonymToAnotherTaxon(heterotypicSynonym
, newTaxon
, moveHomotypicGroup
, newSynonymType
, null, newReferenceDetail
, keepReference
);
607 Assert
.fail("Heterotypic synonym move to other taxon should throw an exception");
608 } catch (HomotypicalGroupChangeException e
) {
609 if (e
.getMessage().contains("Synonym is in homotypic group with other synonym(s). Either move complete homotypic group or remove synonym from homotypic group prior to moving to other taxon")){
611 commitAndStartNewTransaction(tableNames
);
613 Assert
.fail("Unexpected exception occurred: " + e
.getMessage());
617 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn3
);
618 Assert
.assertNotNull("Synonym should still exist", heterotypicSynonym
);
619 Assert
.assertNotNull("Synonym should have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
620 Assert
.assertEquals("Accepted taxon of single relation should still be the old taxon", oldTaxon
, heterotypicSynonym
.getAcceptedTaxon());
623 //test heterotypic synonym with no other synonym in homotypic group
626 newTaxon
= (Taxon
)service
.load(uuidNewTaxon
);
627 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn5
);
628 Assert
.assertNotNull("Synonym should exist", heterotypicSynonym
);
629 Assert
.assertNotNull("Synonym should have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
630 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon
, heterotypicSynonym
.getAcceptedTaxon().getUuid());
631 oldTaxon
= heterotypicSynonym
.getAcceptedTaxon();
632 moveHomotypicGroup
= false;
635 service
.moveSynonymToAnotherTaxon(heterotypicSynonym
, newTaxon
, moveHomotypicGroup
, newSynonymType
, null, newReferenceDetail
, keepReference
);
636 } catch (HomotypicalGroupChangeException e
) {
637 Assert
.fail("Move of single heterotypic synonym should not throw exception: " + e
.getMessage());
640 commitAndStartNewTransaction(tableNames
);
642 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn5
);
643 Assert
.assertNotNull("Synonym should still exist", heterotypicSynonym
);
644 Assert
.assertNotNull("Synonym should have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
645 Assert
.assertEquals("Accepted taxon of single relation should be new taxon", newTaxon
, heterotypicSynonym
.getAcceptedTaxon());
646 Assert
.assertEquals("Old detail should be kept", "rel5", heterotypicSynonym
.getSecMicroReference());
648 //test heterotypic synonym with other synonym in homotypic group and moveHomotypicGroup="true"
650 newTaxon
= (Taxon
)service
.load(uuidNewTaxon
);
651 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn3
);
652 Reference ref1
= referenceService
.load(uuidRef1
);
653 Assert
.assertNotNull("Synonym should exist", heterotypicSynonym
);
654 Assert
.assertNotNull("Synonym should have 1 relation", heterotypicSynonym
.getAcceptedTaxon());
655 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon
, heterotypicSynonym
.getAcceptedTaxon().getUuid());
656 oldTaxon
= heterotypicSynonym
.getAcceptedTaxon();
657 Assert
.assertEquals("Detail should be ref1", ref1
, heterotypicSynonym
.getSec());
658 Assert
.assertEquals("Detail should be 'rel3'", "rel3", heterotypicSynonym
.getSecMicroReference());
659 TaxonName oldSynName3
= heterotypicSynonym
.getName();
661 Synonym heterotypicSynonym4
= (Synonym
)service
.load(uuidSyn4
);
662 Assert
.assertNotNull("Synonym should exist", heterotypicSynonym4
);
663 Assert
.assertNotNull("Synonym should have accepted taxon", heterotypicSynonym4
.getAcceptedTaxon());
664 Assert
.assertEquals("Accepted taxon of other synonym in group should be the old taxon", uuidOldTaxon
, heterotypicSynonym4
.getAcceptedTaxon().getUuid());
665 Assert
.assertSame("Homotypic group of both synonyms should be same", oldSynName3
.getHomotypicalGroup() , heterotypicSynonym4
.getName().getHomotypicalGroup() );
667 moveHomotypicGroup
= true;
668 keepReference
= false;
671 service
.moveSynonymToAnotherTaxon(heterotypicSynonym4
, newTaxon
, moveHomotypicGroup
, newSynonymType
, null, newReferenceDetail
, keepReference
);
672 } catch (HomotypicalGroupChangeException e
) {
673 Assert
.fail("Move with 'moveHomotypicGroup = true' should not throw exception: " + e
.getMessage());
676 commitAndStartNewTransaction(tableNames
);
677 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn3
);
678 Assert
.assertNotNull("Synonym should still exist", heterotypicSynonym
);
679 Assert
.assertNotNull("Synonym should still have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
680 Assert
.assertEquals("Accepted taxon of relation should be new taxon now", newTaxon
, heterotypicSynonym
.getAcceptedTaxon());
681 TaxonName synName3
= heterotypicSynonym
.getName();
683 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn4
);
684 Assert
.assertNotNull("Synonym should still exist", heterotypicSynonym
);
685 Assert
.assertNotNull("Synonym should still have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
686 Assert
.assertEquals("Accepted taxon of relation should be new taxon now", newTaxon
, heterotypicSynonym
.getAcceptedTaxon());
687 Assert
.assertNull("Old citation should be removed", heterotypicSynonym
.getSec());
688 Assert
.assertNull("Old detail should be removed", heterotypicSynonym
.getSecMicroReference());
689 TaxonName synName4
= heterotypicSynonym
.getName();
690 Assert
.assertEquals("Homotypic group of both synonyms should be equal", synName3
.getHomotypicalGroup() , synName4
.getHomotypicalGroup() );
691 Assert
.assertSame("Homotypic group of both synonyms should be same", synName3
.getHomotypicalGroup() , synName4
.getHomotypicalGroup() );
692 Assert
.assertEquals("Homotypic group of both synonyms should be equal to old homotypic group", oldSynName3
.getHomotypicalGroup() , synName3
.getHomotypicalGroup() );
694 //test single heterotypic synonym to homotypic synonym of new taxon
696 newTaxon
= (Taxon
)service
.load(uuidNewTaxon
);
697 Reference ref2
= referenceService
.load(uuidRef2
);
698 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn6
);
699 Assert
.assertNotNull("Synonym should exist", heterotypicSynonym
);
700 Assert
.assertNotNull("Synonym should have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
701 Assert
.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon
, heterotypicSynonym
.getAcceptedTaxon().getUuid());
702 oldTaxon
= heterotypicSynonym
.getAcceptedTaxon();
703 moveHomotypicGroup
= false;
704 keepReference
= false;
706 newReferenceDetail
= "newRefDetail";
707 newSynonymType
= SynonymType
.HOMOTYPIC_SYNONYM_OF();
710 service
.moveSynonymToAnotherTaxon(heterotypicSynonym
, newTaxon
, moveHomotypicGroup
, newSynonymType
, newReference
.getUuid(), newReferenceDetail
, keepReference
);
711 } catch (HomotypicalGroupChangeException e
) {
712 Assert
.fail("Move of single heterotypic synonym should not throw exception: " + e
.getMessage());
715 commitAndStartNewTransaction(tableNames
);
716 heterotypicSynonym
= (Synonym
)service
.load(uuidSyn6
);
717 Assert
.assertNotNull("Synonym should still exist", heterotypicSynonym
);
718 Assert
.assertNotNull("Synonym should still have accepted taxon", heterotypicSynonym
.getAcceptedTaxon());
719 Assert
.assertEquals("Relationship type should be 'homotypic synonym'", newSynonymType
, heterotypicSynonym
.getType());
720 Assert
.assertEquals("Accepted taxon of single relation should be new taxon", newTaxon
, heterotypicSynonym
.getAcceptedTaxon());
721 Assert
.assertEquals("New citation should be ref2", ref2
,heterotypicSynonym
.getSec());
722 Assert
.assertEquals("New detail should be kept", "newRefDetail", heterotypicSynonym
.getSecMicroReference());
724 Assert
.assertEquals("New taxon and new synonym should have equal homotypical group", heterotypicSynonym
.getHomotypicGroup(), heterotypicSynonym
.getAcceptedTaxon().getHomotypicGroup());
725 Assert
.assertSame("New taxon and new synonym should have same homotypical group", heterotypicSynonym
.getHomotypicGroup(), heterotypicSynonym
.getAcceptedTaxon().getHomotypicGroup());
729 public final void testGetHeterotypicSynonymyGroups(){
730 Rank rank
= Rank
.SPECIES();
731 Reference ref1
= ReferenceFactory
.newGeneric();
732 //HomotypicalGroup group = HomotypicalGroup.NewInstance();
733 Taxon taxon1
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test3", null, null, null, null, null, null, null), null);
734 Synonym synonym0
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test2", null, null, null, null, null, null, null), null);
735 Synonym synonym1
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test2", null, null, null, null, null, null, null), null);
736 Synonym synonym2
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test4", null, null, null, null, null, null, null), null);
737 synonym0
.getName().setHomotypicalGroup(taxon1
.getHomotypicGroup());
738 synonym2
.getName().setHomotypicalGroup(synonym1
.getHomotypicGroup());
739 //tax2.addHeterotypicSynonymName(synonym.getName());
740 taxon1
.addSynonym(synonym1
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
741 taxon1
.addSynonym(synonym2
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
743 service
.save(synonym1
);
744 service
.save(synonym2
);
745 service
.save(taxon1
);
747 List
<List
<Synonym
>> heteroSyns
= service
.getHeterotypicSynonymyGroups(taxon1
, null);
748 Assert
.assertEquals("There should be 1 heterotypic group", 1, heteroSyns
.size());
749 List
<Synonym
> synList
= heteroSyns
.get(0);
750 Assert
.assertEquals("There should be 2 heterotypic syns in group 1", 2, synList
.size());
753 synonym2
.setSec(ref1
);
754 heteroSyns
= service
.getHeterotypicSynonymyGroups(taxon1
, null);
755 Assert
.assertEquals("There should be 1 heterotypic group", 1, heteroSyns
.size());
756 synList
= heteroSyns
.get(0);
757 Assert
.assertEquals("getHeterotypicSynonymyGroups should be independent of sec reference", 2, synList
.size());
761 public final void testGetHomotypicSynonymsByHomotypicGroup(){
762 Rank rank
= Rank
.SPECIES();
763 Reference ref1
= ReferenceFactory
.newGeneric();
764 //HomotypicalGroup group = HomotypicalGroup.NewInstance();
765 Taxon taxon1
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test3", null, null, null, null, null, null, null), null);
766 Synonym synonym0
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test2", null, null, null, null, null, null, null), null);
767 Synonym synonym1
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test2", null, null, null, null, null, null, null), null);
768 Synonym synonym2
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test4", null, null, null, null, null, null, null), null);
769 synonym0
.getName().setHomotypicalGroup(taxon1
.getHomotypicGroup());
770 synonym2
.getName().setHomotypicalGroup(synonym1
.getHomotypicGroup());
771 //tax2.addHeterotypicSynonymName(synonym.getName());
772 taxon1
.addSynonym(synonym0
, SynonymType
.HOMOTYPIC_SYNONYM_OF());
773 taxon1
.addSynonym(synonym1
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
774 taxon1
.addSynonym(synonym2
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
776 service
.save(synonym1
);
777 service
.save(synonym2
);
778 service
.save(taxon1
);
780 List
<Synonym
> homoSyns
= service
.getHomotypicSynonymsByHomotypicGroup(taxon1
, null);
781 Assert
.assertEquals("There should be 1 heterotypic group", 1, homoSyns
.size());
782 Assert
.assertSame("The homotypic synonym should be synonym0", synonym0
, homoSyns
.get(0));
785 synonym0
.setSec(ref1
);
786 homoSyns
= service
.getHomotypicSynonymsByHomotypicGroup(taxon1
, null);
787 Assert
.assertEquals("getHeterotypicSynonymyGroups should be independent of sec reference", 1, homoSyns
.size());
791 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
792 //test delete synonym, but the name will not be deleted
793 public final void testDeleteSynonymSynonymTaxonDontDeleteName(){
794 final String
[]tableNames
= {
795 // "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
796 // "HomotypicalGroup","HomotypicalGroup_AUD"
799 int nSynonyms
= service
.count(Synonym
.class);
800 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
801 int nNames
= nameService
.count(TaxonName
.class);
802 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
803 long nRelations
= service
.countSynonyms(true);
804 Assert
.assertEquals("There should be two relationship left in the database", 2, nRelations
);
806 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
808 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
809 SynonymDeletionConfigurator config
= new SynonymDeletionConfigurator();
810 config
.setDeleteNameIfPossible(false);
811 config
.setNewHomotypicGroupIfNeeded(true);
812 service
.deleteSynonym(synonym1
, config
);
814 this.commitAndStartNewTransaction(tableNames
);
816 nSynonyms
= service
.count(Synonym
.class);
817 Assert
.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms
);
818 nNames
= nameService
.count(TaxonName
.class);
819 Assert
.assertEquals("There should be 4 names left in the database", 4, nNames
);
820 nRelations
= service
.countSynonyms(true);
821 Assert
.assertEquals("There should be no relationship left in the database", 1, nRelations
);
825 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
826 //test delete synonym and his name
827 public final void testDeleteSynonymSynonymTaxonDeleteName(){
828 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
829 "HomotypicalGroup","HomotypicalGroup_AUD"};
831 int nSynonyms
= service
.count(Synonym
.class);
832 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
833 int nNames
= nameService
.count(TaxonName
.class);
834 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
835 long nRelations
= service
.countSynonyms(true);
836 Assert
.assertEquals("There should be 2 relationship left in the database", 2, nRelations
);
838 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
839 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
840 service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
842 this.commitAndStartNewTransaction(tableNames
);
844 nSynonyms
= service
.count(Synonym
.class);
845 Assert
.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms
);
846 nNames
= nameService
.count(TaxonName
.class);
847 Assert
.assertEquals("There should be 3 names left in the database", 3, nNames
);
848 nRelations
= service
.countSynonyms(true);
849 Assert
.assertEquals("There should be 1 relationship left in the database", 1, nRelations
);
853 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
854 //test remove synonym from taxon -> synonym and name still in the db and the synonymrelationship to the other taxon
855 //test delete synonym -> all relationships are deleted, the name is deleted and the synonym itself
856 public final void testDeleteSynonymSynonymTaxonBooleanRelToOneTaxon(){
857 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
858 "HomotypicalGroup","HomotypicalGroup_AUD"};
860 int nSynonyms
= service
.count(Synonym
.class);
861 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
862 int nNames
= nameService
.count(TaxonName
.class);
863 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
865 UUID uuidTaxon1
=UUID
.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
866 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
868 Taxon taxon2
= (Taxon
)service
.load(uuidTaxon1
);
870 List
<String
> initStrat
= new ArrayList
<>();
871 initStrat
.add("markers");
872 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
, initStrat
);
873 long nRelations
= service
.countSynonyms(true);
874 Assert
.assertEquals("There should be 2 relationship left in the database", 2, nRelations
);
876 taxon2
.removeSynonym(synonym1
, false);
877 service
.saveOrUpdate(taxon2
);
879 commitAndStartNewTransaction(null);
881 nSynonyms
= service
.count(Synonym
.class);
882 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
883 nNames
= nameService
.count(TaxonName
.class);
884 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
885 nRelations
= service
.countSynonyms(true);
886 Assert
.assertEquals("There should be 1 relationship left in the database", 1, nRelations
);
887 Marker marker1
= Marker
.NewInstance(MarkerType
.IMPORTED(), true);
888 Marker marker2
= Marker
.NewInstance(MarkerType
.COMPUTED(), true);
889 synonym1
.addMarker(marker1
);
890 synonym1
.addMarker(marker2
);
891 service
.update(synonym1
);
892 synonym1
=(Synonym
) service
.load(uuidSynonym1
);
894 Set
<Marker
> markers
= synonym1
.getMarkers();
895 Marker marker
= markers
.iterator().next();
896 UUID markerUUID
= marker
.getUuid();
897 // taxon2 = (Taxon)service.load(uuidTaxon2);
898 synonym1
= (Synonym
)service
.load(uuidSynonym1
);
899 //the marker should not prevent the deletion
900 DeleteResult result
= service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
905 commitAndStartNewTransaction(tableNames
);
906 nSynonyms
= service
.count(Synonym
.class);
907 Assert
.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms
);
908 nNames
= nameService
.count(TaxonName
.class);
909 Assert
.assertEquals("There should be 3 names left in the database", 3, nNames
);
910 nRelations
= service
.countSynonyms(true);
911 Assert
.assertEquals("There should be no relationship left in the database", 1, nRelations
);
912 marker
= markerService
.load(markerUUID
);
917 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
918 //this test is more or less obsolete since we have no synonym relationships anymore
919 //test delete synonym, only for a special taxon, but because of other relationships it will not be deleted at all
920 public final void testDeleteSynonymSynonymTaxonBooleanDeleteOneTaxon(){
921 final String
[]tableNames
= {
922 // "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
923 // "HomotypicalGroup","HomotypicalGroup_AUD"
925 int nSynonyms
= service
.count(Synonym
.class);
926 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
927 int nNames
= nameService
.count(TaxonName
.class);
928 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
930 UUID uuidTaxon2
=UUID
.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");
931 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
933 Taxon taxon2
= (Taxon
)service
.load(uuidTaxon2
);
934 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
935 synonym1
.setSec(ReferenceFactory
.newArticle());
937 taxon2
.addSynonym(synonym1
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
938 service
.saveOrUpdate(synonym1
);
939 long nRelations
= service
.countSynonyms(true);
940 //this was "3" when we still had synonym relationships
941 Assert
.assertEquals("There should be 2 relationship left in the database", 2, nRelations
);
942 service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
944 this.commitAndStartNewTransaction(tableNames
);
946 nSynonyms
= service
.count(Synonym
.class);
947 //this was "2" when we still had synonym relationships
948 Assert
.assertEquals("There should still be 1 synonym left in the database", 1, nSynonyms
);
949 nNames
= nameService
.count(TaxonName
.class);
951 Assert
.assertEquals("There should be 3 names left in the database", 3, nNames
);
952 nRelations
= service
.countSynonyms(true);
953 Assert
.assertEquals("There should be 1 related synonym left in the database", 1, nRelations
);
957 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
959 public final void testDeleteSynonymWithAnnotations(){
960 final String
[]tableNames
= {
961 // "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
962 // "HomotypicalGroup","HomotypicalGroup_AUD"
965 UUID uuidTaxon2
=UUID
.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");
966 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
968 Taxon taxon2
= (Taxon
)service
.load(uuidTaxon2
);
969 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
970 taxon2
.addSynonym(synonym1
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
972 Annotation annotation
= Annotation
.NewDefaultLanguageInstance("test");
973 synonym1
.addAnnotation(annotation
);
974 service
.saveOrUpdate(synonym1
);
976 DeleteResult result
= service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
977 if (result
.isError()){
980 this.commitAndStartNewTransaction(tableNames
);
984 @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
986 public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedName(){
987 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
988 "HomotypicalGroup","HomotypicalGroup_AUD"};
990 int nSynonyms
= service
.count(Synonym
.class);
991 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
992 int nNames
= nameService
.count(TaxonName
.class);
993 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
995 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
996 UUID uuidSynonymName2
=UUID
.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
998 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
999 TaxonName name2
= nameService
.load(uuidSynonymName2
);
1000 UUID name3Uuid
= synonym1
.getName().getUuid();
1001 TaxonName name3
= nameService
.load(name3Uuid
);
1002 name3
.addRelationshipFromName(name2
, NameRelationshipType
.LATER_HOMONYM(), null, null);
1004 service
.saveOrUpdate(synonym1
);
1006 long nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1007 logger
.info("number of name relations: " + nRelations
);
1008 Assert
.assertEquals("There should be 1 name relationship left in the database", 1, nRelations
);
1009 SynonymDeletionConfigurator config
= new SynonymDeletionConfigurator();
1011 service
.deleteSynonym(synonym1
, config
);
1013 this.commitAndStartNewTransaction(tableNames
);
1014 //synonym is deleted, but the name can not be deleted because of a name relationship
1015 nSynonyms
= service
.count(Synonym
.class);
1016 Assert
.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms
);
1017 nNames
= nameService
.count(TaxonName
.class);
1018 Assert
.assertEquals("There should be 4 names left in the database (name is related to synonymName2)", 4, nNames
);
1019 nRelations
= service
.countSynonyms(true);
1020 //may change with better implementation of countAllRelationships (see #2653)
1021 nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1022 logger
.info("number of name relations: " + nRelations
);
1023 Assert
.assertEquals("There should be 1 name relationship left in the database", 1, nRelations
);
1026 name2
= nameService
.load(uuidSynonymName2
);
1027 NameRelationship rel
= CdmBase
.deproxy(name2
.getNameRelations().iterator().next(), NameRelationship
.class);
1028 name2
.removeNameRelationship(rel
);
1029 nameService
.save(name2
);
1031 this.endTransaction();
1035 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
1036 public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameDeleteAllNameRelations(){
1037 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
1038 "HomotypicalGroup","HomotypicalGroup_AUD"};
1040 int nSynonyms
= service
.count(Synonym
.class);
1041 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
1042 int nNames
= nameService
.count(TaxonName
.class);
1043 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
1045 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
1046 UUID uuidSynonymName2
=UUID
.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
1048 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
1049 TaxonName name2
= nameService
.load(uuidSynonymName2
);
1050 UUID name3Uuid
= synonym1
.getName().getUuid();
1051 TaxonName name3
= nameService
.load(name3Uuid
);
1052 name3
.addRelationshipFromName(name2
, NameRelationshipType
.LATER_HOMONYM(), null, null);
1054 service
.saveOrUpdate(synonym1
);
1056 long nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1057 logger
.info("number of name relations: " + nRelations
);
1058 Assert
.assertEquals("There should be 1 name relationship left in the database", 1, nRelations
);
1059 SynonymDeletionConfigurator config
= new SynonymDeletionConfigurator();
1060 NameDeletionConfigurator nameDeletionConfig
= new NameDeletionConfigurator();
1061 nameDeletionConfig
.setRemoveAllNameRelationships(true);
1062 config
.setNameDeletionConfig(nameDeletionConfig
);
1064 service
.deleteSynonym(synonym1
, config
);
1066 this.commitAndStartNewTransaction(tableNames
);
1068 nSynonyms
= service
.count(Synonym
.class);
1069 Assert
.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms
);
1070 nNames
= nameService
.count(TaxonName
.class);
1071 Assert
.assertEquals("There should be 3 names left in the database ", 3, nNames
);
1072 nRelations
= service
.countSynonyms(true);
1073 //may change with better implementation of countAllRelationships (see #2653)
1074 nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1075 logger
.info("number of name relations: " + nRelations
);
1076 Assert
.assertEquals("There should be no name relationship left in the database", 0, nRelations
);
1080 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="TaxonServiceImplTest.testDeleteSynonym.xml")
1081 public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameIgnoreIsBasionym(){
1082 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
1083 "HomotypicalGroup","HomotypicalGroup_AUD"};
1085 int nSynonyms
= service
.count(Synonym
.class);
1086 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
1087 int nNames
= nameService
.count(TaxonName
.class);
1088 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
1090 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
1091 UUID uuidSynonymName2
=UUID
.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
1093 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
1094 TaxonName synName2
= nameService
.load(uuidSynonymName2
);
1095 UUID name3Uuid
= synonym1
.getName().getUuid();
1096 TaxonName synName1
= nameService
.load(name3Uuid
);
1097 synName1
.addRelationshipFromName(synName2
, NameRelationshipType
.BASIONYM(), null, null);
1099 service
.saveOrUpdate(synonym1
);
1101 long nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1102 logger
.info("number of name relations: " + nRelations
);
1103 Assert
.assertEquals("There should be 1 name relationship left in the database", 1, nRelations
);
1104 SynonymDeletionConfigurator config
= new SynonymDeletionConfigurator();
1105 NameDeletionConfigurator nameDeletionConfig
= new NameDeletionConfigurator();
1106 nameDeletionConfig
.setIgnoreIsBasionymFor(true);
1107 config
.setNameDeletionConfig(nameDeletionConfig
);
1109 DeleteResult result
=service
.deleteSynonym(synonym1
, config
);
1110 if (!result
.isOk()){
1114 logger
.debug(result
);
1115 this.commitAndStartNewTransaction(tableNames
);
1117 nSynonyms
= service
.count(Synonym
.class);
1118 Assert
.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms
);
1119 nNames
= nameService
.count(TaxonName
.class);
1120 Assert
.assertEquals("There should be 3 names left in the database ", 3, nNames
);
1121 nRelations
= service
.countSynonyms(true);
1122 //may change with better implementation of countAllRelationships (see #2653)
1123 nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1124 logger
.info("number of name relations: " + nRelations
);
1125 Assert
.assertEquals("There should be no name relationship left in the database", 0, nRelations
);
1129 @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
1130 public final void testDeleteSynonymSynonymTaxonBooleanWithRollback(){
1131 // final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
1132 // "HomotypicalGroup","HomotypicalGroup_AUD"};
1134 int nSynonyms
= service
.count(Synonym
.class);
1135 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
1136 int nNames
= nameService
.count(TaxonName
.class);
1137 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
1138 long nRelations
= service
.countSynonyms(true);
1140 //may change with better implementation of countAllRelationships (see #2653)
1143 Assert
.assertEquals("There should be 2 relationships in the database (the 2 synonym relationship) but no name relationship", 2, nRelations
);
1145 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
1146 UUID uuidSynonymName2
=UUID
.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
1148 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
1149 TaxonName name2
= nameService
.load(uuidSynonymName2
);
1150 synonym1
.getName().addRelationshipFromName(name2
, NameRelationshipType
.LATER_HOMONYM(), null, null);
1152 service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
1155 // printDataSet(System.out, tableNames);
1156 this.startNewTransaction();
1158 nSynonyms
= service
.count(Synonym
.class);
1159 Assert
.assertEquals("There should still be 2 synonyms left in the database", 2, nSynonyms
);
1160 nNames
= nameService
.count(TaxonName
.class);
1161 Assert
.assertEquals("There should be 4 names left in the database", 4, nNames
);
1162 nRelations
= service
.countSynonyms(true);
1163 //may change with better implementation of countAllRelationships (see #2653)
1164 Assert
.assertEquals("There should be 2 relationship in the database (the 2 synonym relationship) but no name relationship", 2, nRelations
);
1168 @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
1169 public final void testDeleteSynonymSynonymTaxonBooleanWithoutTransaction(){
1170 @SuppressWarnings("unused")
1171 final String
[]tableNames
= {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
1172 "HomotypicalGroup","HomotypicalGroup_AUD"};
1174 int nSynonyms
= service
.count(Synonym
.class);
1175 Assert
.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms
);
1176 int nNames
= nameService
.count(TaxonName
.class);
1177 Assert
.assertEquals("There should be 4 names in the database", 4, nNames
);
1178 long nRelations
= service
.countSynonyms(true);
1179 //may change with better implementation of countAllRelationships (see #2653)
1180 Assert
.assertEquals("There should be 2 relationship in the database (the 2 synonym relationships) but no name relationship", 2, nRelations
);
1182 UUID uuidSynonym1
=UUID
.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
1183 UUID uuidSynonymName2
=UUID
.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
1185 Synonym synonym1
= (Synonym
)service
.load(uuidSynonym1
);
1186 TaxonName name2
= nameService
.load(uuidSynonymName2
);
1187 synonym1
.getName().addRelationshipFromName(name2
, NameRelationshipType
.LATER_HOMONYM(), null, null);
1189 service
.saveOrUpdate(synonym1
);
1190 nRelations
= service
.countSynonyms(true);
1191 Assert
.assertEquals("There should be two relationships in the database", 2, nRelations
);
1193 this.endTransaction();
1195 // printDataSet(System.out, tableNames);
1197 //out of wrapping transaction
1198 service
.deleteSynonym(synonym1
, new SynonymDeletionConfigurator());
1200 this.startNewTransaction();
1202 nSynonyms
= service
.count(Synonym
.class);
1203 Assert
.assertEquals("There should still be 1 synonyms left in the database. The rollback on name delete should not lead to rollback in synonym delete.", 1, nSynonyms
);
1204 nNames
= nameService
.count(TaxonName
.class);
1205 Assert
.assertEquals("There should be 4 names left in the database", 4, nNames
);
1206 nRelations
= service
.countSynonyms(true);
1207 Assert
.assertEquals("There should be no taxon or synonym relationship in the database", 1, nRelations
);
1208 nRelations
= nameService
.listNameRelationships(null, 1000, 0, null, null).size();
1209 Assert
.assertEquals("There should be one name relationship in the database", 1, nRelations
);
1213 @DataSet("TaxonServiceImplTest.testInferredSynonyms.xml")
1214 public void testCreateInferredSynonymy(){
1216 UUID classificationUuid
= UUID
.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");
1217 Classification tree
= classificationService
.find(classificationUuid
);
1218 UUID taxonUuid
= UUID
.fromString("bc09aca6-06fd-4905-b1e7-cbf7cc65d783");
1219 TaxonBase
<?
> taxonBase
= service
.find(taxonUuid
);
1220 List
<Synonym
> synonyms
= service
.list(Synonym
.class, null, null, null, null);
1221 assertEquals("Number of synonyms should be 2",2,synonyms
.size());
1222 Taxon taxon
= (Taxon
)taxonBase
;
1224 //synonyms = taxonDao.getAllSynonyms(null, null);
1225 //assertEquals("Number of synonyms should be 2",2,synonyms.size());
1226 List
<Synonym
> inferredSynonyms
= service
.createInferredSynonyms(taxon
, tree
, SynonymType
.INFERRED_EPITHET_OF(), true);
1227 assertNotNull("there should be a new synonym ", inferredSynonyms
);
1228 assertEquals ("the name of inferred epithet should be SynGenus lachesis", "SynGenus lachesis syn. sec. Sp. Pl.", inferredSynonyms
.get(0).getTitleCache());
1230 inferredSynonyms
= service
.createInferredSynonyms(taxon
, tree
, SynonymType
.INFERRED_GENUS_OF(), true);
1231 assertNotNull("there should be a new synonym ", inferredSynonyms
);
1232 assertEquals ("the name of inferred epithet should be SynGenus lachesis", "Acherontia ciprosus syn. sec. Sp. Pl.", inferredSynonyms
.get(0).getTitleCache());
1234 inferredSynonyms
= service
.createInferredSynonyms(taxon
, tree
, SynonymType
.POTENTIAL_COMBINATION_OF(), true);
1235 assertNotNull("there should be a new synonym ", inferredSynonyms
);
1236 assertEquals ("the name of inferred epithet should be SynGenus lachesis", "SynGenus ciprosus syn. sec. Sp. Pl.", inferredSynonyms
.get(0).getTitleCache());
1237 //assertTrue("set of synonyms should contain an inferred Synonym ", synonyms.contains(arg0))
1241 @DataSet("../../database/ClearDBDataSet.xml")
1242 public final void testTaxonDeletionConfig(){
1243 final String
[]tableNames
= {}
1244 // "Classification", "Classification_AUD",
1245 // "TaxonBase","TaxonBase_AUD",
1246 // "TaxonNode","TaxonNode_AUD",
1247 // "TaxonName","TaxonName_AUD",
1248 // "TaxonRelationship", "TaxonRelationship_AUD",
1249 // "TaxonDescription", "TaxonDescription_AUD",
1250 // "HomotypicalGroup","HomotypicalGroup_AUD",
1251 // "PolytomousKey","PolytomousKey_AUD",
1252 // "PolytomousKeyNode","PolytomousKeyNode_AUD",
1253 // "Media","Media_AUD",
1254 // "DescriptiveDataSet","DescriptiveDataSet_AUD",
1255 // "DescriptionElementBase","DescriptionElementBase_AUD",
1256 // "DeterminationEvent","DeterminationEvent_AUD",
1257 // "SpecimenOrObservationBase","SpecimenOrObservationBase_AUD"}
1260 commitAndStartNewTransaction(tableNames
);
1262 commitAndStartNewTransaction(tableNames
);
1263 int nTaxa
= service
.count(Taxon
.class);
1265 Assert
.assertEquals("There should be 4 taxa in the database", 4, nTaxa
);
1266 Taxon parent
= (Taxon
)service
.find(GENUS_UUID
);
1267 Assert
.assertNotNull("Parent taxon should exist", parent
);
1268 Taxon child1
= (Taxon
)service
.find(SPECIES1_UUID
);
1269 Assert
.assertNotNull("Child taxon should exist", child1
);
1270 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1271 config
.setDeleteTaxonNodes(false);
1272 config
.setDeleteMisappliedNames(false);
1274 //commitAndStartNewTransaction(tableNames);
1276 DeleteResult result
= service
.deleteTaxon(child1
.getUuid(), config
, null);
1278 Assert
.fail("Delete should throw an error as long as name is used in classification.");
1281 nTaxa
= service
.count(Taxon
.class);
1282 Assert
.assertEquals("There should be 4 taxa in the database", 4, nTaxa
);
1283 child1
= (Taxon
)service
.find(SPECIES1_UUID
);
1284 Assert
.assertNotNull("Child taxon should exist", child1
);
1285 Assert
.assertEquals("Child should belong to 1 node", 1, child1
.getTaxonNodes().size());
1287 TaxonNode node
= child1
.getTaxonNodes().iterator().next();
1288 child1
.addSource(IdentifiableSource
.NewInstance(OriginalSourceType
.Import
));
1290 SpecimenOrObservationBase
<?
> identifiedUnit
= DerivedUnit
.NewInstance(SpecimenOrObservationType
.DerivedUnit
);
1291 DeterminationEvent
.NewInstance(child1
, identifiedUnit
);
1292 //UUID eventUUID = eventService.save(determinationEvent);
1293 UUID identifiedUnitUUID
= occurenceService
.save(identifiedUnit
).getUuid();
1295 TaxonNode parentNode
= node
.getParent();
1296 parentNode
=CdmBase
.deproxy(parentNode
, TaxonNode
.class);
1297 parentNode
.deleteChildNode(node
);
1298 nodeService
.save(parentNode
);
1299 //commitAndStartNewTransaction(tableNames);
1303 result
= service
.deleteTaxon(child1
1304 .getUuid(), config
, null);
1306 Assert
.fail("Delete should throw an exception because of the determination event");
1309 //determinationEvent = (DeterminationEvent)eventService.load(eventUUID);
1310 commitAndStartNewTransaction(tableNames
);
1311 identifiedUnit
= occurenceService
.load(identifiedUnitUUID
);
1313 occurenceService
.delete(identifiedUnit
);
1315 commitAndStartNewTransaction(tableNames
);
1316 child1
= (Taxon
)service
.find(SPECIES1_UUID
);
1318 assertEquals(0, child1
.getTaxonNodes().size());
1321 result
= service
.deleteTaxon(child1
.getUuid(), config
, null);
1323 if (!result
.isOk()){
1324 Assert
.fail("Delete should not throw an exception anymore");
1327 nTaxa
= service
.count(Taxon
.class);
1328 Assert
.assertEquals("There should be 3 taxa in the database", 3, nTaxa
);
1330 config
.setDeleteTaxonNodes(true);
1331 Taxon child2
=(Taxon
) service
.find(SPECIES2_UUID
);
1334 result
= service
.deleteTaxon(child2
.getUuid(), config
, child2
.getTaxonNodes().iterator().next().getClassification().getUuid());
1335 if (!result
.isOk()){
1336 Assert
.fail("Delete should not throw an exception");
1339 //service.find(uuid);
1341 nTaxa
= service
.count(Taxon
.class);
1342 Assert
.assertEquals("There should be 2 taxa in the database",2, nTaxa
);
1343 // nNames = nameService.count(TaxonName.class);
1344 // Assert.assertEquals("There should be 3 names left in the database", 3, nNames);
1345 // int nRelations = service.countAllRelationships();
1346 // Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);
1350 @DataSet(value
="../../database/ClearDBDataSet.xml")
1351 public final void testDeleteTaxon(){
1353 //create a small classification
1354 Taxon testTaxon
= getTestTaxon();
1355 service
.save(testTaxon
).getUuid();
1357 Taxon speciesTaxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1358 Iterator
<TaxonDescription
> descriptionIterator
= speciesTaxon
.getDescriptions().iterator();
1359 UUID descrUUID
= null;
1360 UUID descrElementUUID
= null;
1361 if (descriptionIterator
.hasNext()){
1362 TaxonDescription descr
= descriptionIterator
.next();
1363 descrUUID
= descr
.getUuid();
1364 descrElementUUID
= descr
.getElements().iterator().next().getUuid();
1366 IBotanicalName taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1367 assertNotNull(taxonName
);
1369 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1370 config
.setDeleteNameIfPossible(false);
1372 DeleteResult result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1373 if (!result
.isOk()){
1376 commitAndStartNewTransaction(null);
1378 taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1379 Taxon taxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1381 //descriptionService.find(descrUUID);
1382 assertNull(descriptionService
.find(descrUUID
));
1383 assertNull(descriptionService
.getDescriptionElementByUuid(descrElementUUID
));
1384 //assertNull(synName);
1385 assertNotNull(taxonName
);
1387 config
.setDeleteNameIfPossible(true);
1388 Taxon newTaxon
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES()), null);
1389 service
.save(newTaxon
);
1390 result
= service
.deleteTaxon(newTaxon
.getUuid()
1392 if (!result
.isOk()){
1398 @DataSet(value
="../../database/ClearDBDataSet.xml")
1399 public final void testDeleteTaxonWithAnnotations(){
1401 //create a small classification
1402 Taxon testTaxon
= getTestTaxon();
1403 service
.save(testTaxon
).getUuid();
1405 Taxon speciesTaxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1406 Iterator
<TaxonDescription
> descriptionIterator
= speciesTaxon
.getDescriptions().iterator();
1407 UUID descrUUID
= null;
1408 UUID descrElementUUID
= null;
1409 if (descriptionIterator
.hasNext()){
1410 TaxonDescription descr
= descriptionIterator
.next();
1411 descrUUID
= descr
.getUuid();
1412 descrElementUUID
= descr
.getElements().iterator().next().getUuid();
1414 IBotanicalName taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1415 assertNotNull(taxonName
);
1417 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1418 config
.setDeleteNameIfPossible(false);
1419 Annotation annotation
= Annotation
.NewDefaultLanguageInstance("test");
1420 speciesTaxon
.addAnnotation(annotation
);
1423 DeleteResult result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1424 if (!result
.isOk()){
1427 commitAndStartNewTransaction(null);
1429 taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1430 Taxon taxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1432 //descriptionService.find(descrUUID);
1433 assertNull(descriptionService
.find(descrUUID
));
1434 assertNull(descriptionService
.getDescriptionElementByUuid(descrElementUUID
));
1435 //assertNull(synName);
1436 assertNotNull(taxonName
);
1438 config
.setDeleteNameIfPossible(true);
1439 Taxon newTaxon
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES()), null);
1440 service
.save(newTaxon
);
1441 result
= service
.deleteTaxon(newTaxon
.getUuid()
1443 if (!result
.isOk()){
1449 @DataSet(value
="../../database/ClearDBDataSet.xml")
1450 public final void testDeleteTaxonUsedInTaxonRelation(){
1452 //create a small classification
1453 Taxon testTaxon
= getTestTaxon();
1454 service
.save(testTaxon
).getUuid();
1456 Taxon speciesTaxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1457 Taxon speciesTaxon2
= (Taxon
)service
.find(SPECIES2_UUID
);
1458 speciesTaxon
.addTaxonRelation(speciesTaxon2
, TaxonRelationshipType
.MISAPPLIED_NAME_FOR(), null, null);
1460 IBotanicalName taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1461 assertNotNull(taxonName
);
1463 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1464 config
.setDeleteNameIfPossible(false);
1465 config
.setDeleteTaxonRelationships(false);
1468 DeleteResult result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1472 commitAndStartNewTransaction(null);
1474 taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1475 Taxon taxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1477 assertNotNull(taxonName
);
1478 assertNotNull(taxon
);
1480 config
.setDeleteNameIfPossible(false);
1481 config
.setDeleteTaxonRelationships(true);
1484 result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1485 if (!result
.isOk()){
1488 commitAndStartNewTransaction(null);
1490 config
.setDeleteNameIfPossible(true);
1491 Taxon newTaxon
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES()), null);
1492 service
.save(newTaxon
);
1493 result
= service
.deleteTaxon(newTaxon
.getUuid()
1495 if (!result
.isOk()){
1501 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="../../database/ClearDBDataSet.xml")
1502 public final void testDeleteTaxonDeleteSynonymRelations(){
1504 final String
[]tableNames
= {
1505 "Classification", "Classification_AUD",
1506 "TaxonBase","TaxonBase_AUD",
1507 "TaxonNode","TaxonNode_AUD",
1508 "TaxonName","TaxonName_AUD"};
1509 commitAndStartNewTransaction(tableNames
);
1510 //create a small classification
1511 Taxon testTaxon
= getTestTaxon();
1512 service
.save(testTaxon
).getUuid();
1513 Taxon speciesTaxon
= (Taxon
)service
.find(SPECIES2_UUID
);
1515 Synonym synonym
= speciesTaxon
.getSynonyms().iterator().next();
1516 UUID synonymUuid
= synonym
.getUuid();
1517 service
.countSynonyms(true);
1519 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1520 config
.setDeleteSynonymsIfPossible(false);
1523 DeleteResult result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1524 if (!result
.isOk()){
1527 commitAndStartNewTransaction(null);
1529 Taxon taxon
= (Taxon
)service
.find(SPECIES2_UUID
);
1530 assertNull("The deleted taxon should no longer exist", taxon
);
1532 Synonym syn
= (Synonym
)service
.find(synonymUuid
);
1533 assertNotNull("The synonym should still exist since DeleteSynonymsIfPossible was false", service
.find(synonymUuid
));
1534 assertNull("The synonym should not be attached to an accepted taxon anymore", syn
.getAcceptedTaxon());
1538 @DataSet(value
="../../database/ClearDBDataSet.xml")
1539 public final void testDeleteTaxonNameUsedInOtherContext(){
1541 //create a small classification
1542 Taxon testTaxon
= getTestTaxon();
1543 service
.save(testTaxon
).getUuid();
1544 Taxon speciesTaxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1546 IBotanicalName taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1547 assertNotNull(taxonName
);
1548 TaxonName fromName
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
1549 taxonName
.addRelationshipFromName(fromName
, NameRelationshipType
.VALIDATED_BY_NAME(), null, null);
1550 nameService
.save(fromName
);
1552 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1553 config
.setDeleteNameIfPossible(true);
1554 DeleteResult result
= service
.deleteTaxon(speciesTaxon
.getUuid(), config
, speciesTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1555 if (!result
.isOk()){
1558 commitAndStartNewTransaction(null);
1560 taxonName
= nameService
.find(SPECIES1_NAME_UUID
);
1561 Taxon taxon
= (Taxon
)service
.find(SPECIES1_UUID
);
1562 //because of the namerelationship the name cannot be deleted
1563 assertNotNull(taxonName
);
1568 @DataSet(value
="../../database/ClearDBDataSet.xml")
1569 public final void testDeleteTaxonNameUsedInTwoClassificationsDeleteAllNodes(){
1570 commitAndStartNewTransaction(null);
1571 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator();
1572 //create a small classification
1573 Taxon testTaxon
= getTestTaxon();
1575 UUID uuid
= service
.save(testTaxon
).getUuid();
1576 //BotanicalName name = nameService.find(uuid);
1577 Set
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes();
1578 TaxonNode node
= nodes
.iterator().next();
1579 List
<TaxonNode
> childNodes
= node
.getChildNodes();
1580 TaxonNode childNode
= childNodes
.iterator().next();
1581 UUID childUUID
= childNode
.getTaxon().getUuid();
1582 Classification secondClassification
= getTestClassification("secondClassification");
1584 secondClassification
.addChildTaxon(testTaxon
, null, null);
1585 //delete the taxon in all classifications
1586 config
.setDeleteInAllClassifications(true);
1587 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, null);
1588 if (!result
.isOk()){
1591 commitAndStartNewTransaction(null);
1592 Taxon tax
= (Taxon
)service
.find(uuid
);
1594 Taxon childTaxon
= (Taxon
)service
.find(childUUID
);
1596 commitAndStartNewTransaction(null);
1600 @DataSet(value
="../../database/ClearDBDataSet.xml")
1601 public final void testDeleteTaxonNameUsedInTwoClassificationsDoNotDeleteAllNodes(){
1602 // delete the taxon only in second classification, this should delete only the nodes, not the taxa
1603 Taxon testTaxon
= getTestTaxon();
1604 UUID uuid
= service
.save(testTaxon
).getUuid();
1605 Classification secondClassification
= getTestClassification("secondClassification");
1606 Set
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes();
1607 TaxonNode node
= nodes
.iterator().next();
1608 List
<TaxonNode
> childNodes
= node
.getChildNodes();
1609 TaxonNode childNode
= childNodes
.iterator().next();
1610 UUID childUUID
= childNode
.getTaxon().getUuid();
1611 childNode
= secondClassification
.addChildTaxon(testTaxon
, null, null);
1612 UUID childNodeUUID
= childNode
.getUuid();
1614 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1615 config
.setDeleteInAllClassifications(false);
1617 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, secondClassification
.getUuid());
1618 /* Assert.fail("The taxon should not be deletable because it is used in a second classification and the configuration is set to deleteInAllClassifications = false");
1619 } catch (DataChangeNoRollbackException e) {
1620 logger.debug(e.getMessage());
1625 Assert
.fail("The taxon should not be deletable because it is used in a second classification and the configuration is set to deleteInAllClassifications = false");
1628 //commitAndStartNewTransaction(null);
1629 Taxon tax
= (Taxon
)service
.find(uuid
);
1631 Taxon childTaxon
= (Taxon
)service
.find(childUUID
);
1633 //when calling delete taxon and the taxon can not be deleted the children should not be deleted as well. If children should be deleted call delete taxonnode
1634 node
= nodeService
.find(childNodeUUID
);
1635 assertNotNull(node
);
1639 @DataSet(value
="../../database/ClearDBDataSet.xml")
1640 public final void testTaxonNodeDeletionConfiguratorMoveToParent(){
1641 //test childHandling MOVE_TO_PARENT:
1642 Taxon testTaxon
= getTestTaxon();
1643 UUID uuid
= service
.save(testTaxon
).getUuid();
1645 Taxon topMost
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.FAMILY()), null);
1647 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1648 TaxonNode node
=nodes
.next();
1649 Classification classification
= node
.getClassification();
1650 classification
.addParentChild(topMost
, testTaxon
, null, null);
1651 UUID topMostUUID
= service
.save(topMost
).getUuid();
1653 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1654 config
.getTaxonNodeConfig().setChildHandling(ChildHandling
.MOVE_TO_PARENT
);
1657 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, classification
.getUuid());
1662 commitAndStartNewTransaction(null);
1663 Taxon tax
= (Taxon
)service
.find(uuid
);
1665 tax
= (Taxon
)service
.find(topMostUUID
);
1666 Set
<TaxonNode
> topMostNodes
= tax
.getTaxonNodes();
1667 assertNotNull(topMostNodes
);
1668 assertEquals("there should be one taxon node", 1, topMostNodes
.size());
1669 nodes
= topMostNodes
.iterator();
1670 TaxonNode topMostNode
= nodes
.next();
1671 int size
= topMostNode
.getChildNodes().size();
1673 assertEquals(2, size
);
1677 @DataSet(value
="../../database/ClearDBDataSet.xml")
1678 public final void testTaxonNodeDeletionConfiguratorDeleteChildren(){
1679 //test childHandling DELETE:
1680 Taxon testTaxon
= getTestTaxon();
1681 UUID uuid
= service
.save(testTaxon
).getUuid();
1683 Taxon topMost
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.FAMILY()), null);
1685 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1686 TaxonNode node
=nodes
.next();
1687 UUID taxonNodeUUID
= node
.getUuid();
1688 Classification classification
= node
.getClassification();
1689 classification
.addParentChild(topMost
, testTaxon
, null, null);
1690 UUID topMostUUID
= service
.save(topMost
).getUuid();
1692 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1693 config
.getTaxonNodeConfig().setChildHandling(ChildHandling
.DELETE
);
1696 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, testTaxon
.getTaxonNodes().iterator().next().getClassification().getUuid());
1700 commitAndStartNewTransaction(null);
1701 Taxon tax
= (Taxon
)service
.find(uuid
);
1703 tax
= (Taxon
)service
.find(topMostUUID
);
1704 Set
<TaxonNode
> topMostNodes
= tax
.getTaxonNodes();
1705 assertNotNull(topMostNodes
);
1706 assertEquals("there should be one taxon node", 1, topMostNodes
.size());
1707 nodes
= topMostNodes
.iterator();
1708 TaxonNode topMostNode
= nodes
.next();
1709 int size
= topMostNode
.getChildNodes().size();
1710 node
= nodeService
.find(taxonNodeUUID
);
1712 assertEquals(0, size
);
1717 @DataSet(value
="../../database/ClearDBDataSet.xml")
1718 public final void testTaxonDeletionConfiguratorDeleteMarker(){
1719 //test childHandling DELETE:
1720 Taxon testTaxon
= getTestTaxon();
1721 UUID uuid
= service
.save(testTaxon
).getUuid();
1723 Taxon topMost
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.FAMILY()), null);
1725 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1726 TaxonNode node
=nodes
.next();
1727 Classification classification
= node
.getClassification();
1728 classification
.addParentChild(topMost
, testTaxon
, null, null);
1729 UUID topMostUUID
= service
.save(topMost
).getUuid();
1730 Marker marker
= Marker
.NewInstance(testTaxon
, true, MarkerType
.IS_DOUBTFUL());
1731 testTaxon
.addMarker(marker
);
1732 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1733 config
.getTaxonNodeConfig().setChildHandling(ChildHandling
.DELETE
);
1735 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, node
.getClassification().getUuid());
1740 commitAndStartNewTransaction(null);
1741 Taxon tax
= (Taxon
)service
.find(uuid
);
1743 tax
= (Taxon
)service
.find(topMostUUID
);
1744 Set
<TaxonNode
> topMostNodes
= tax
.getTaxonNodes();
1745 assertNotNull(topMostNodes
);
1746 assertEquals("there should be one taxon node", 1, topMostNodes
.size());
1747 nodes
= topMostNodes
.iterator();
1748 TaxonNode topMostNode
= nodes
.next();
1749 int size
= topMostNode
.getChildNodes().size();
1751 assertEquals(0, size
);
1756 @DataSet(value
="../../database/ClearDBDataSet.xml")
1757 public final void testTaxonDeletionConfiguratorTaxonWithMisappliedName(){
1759 Taxon testTaxon
= getTestTaxon();
1760 UUID uuid
= service
.save(testTaxon
).getUuid();
1762 Taxon misappliedName
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.GENUS()), null);
1764 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1765 TaxonNode node
=nodes
.next();
1766 testTaxon
.addMisappliedName(misappliedName
, null, null);
1767 UUID misappliedNameUUID
= service
.save(misappliedName
).getUuid();
1769 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1770 config
.setDeleteMisappliedNames(true);
1772 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, node
.getClassification().getUuid());
1776 commitAndStartNewTransaction(null);
1777 Taxon tax
= (Taxon
)service
.find(uuid
);
1779 tax
= (Taxon
)service
.find(misappliedNameUUID
);
1780 //TODO: is that correct or should it be deleted because there is no relation to anything
1785 @DataSet(value
="../../database/ClearDBDataSet.xml")
1786 public final void testTaxonDeletionConfiguratorTaxonWithMisappliedNameDoNotDelete(){
1788 Taxon testTaxon
= getTestTaxon();
1789 UUID uuid
= service
.save(testTaxon
).getUuid();
1791 Taxon misappliedName
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.GENUS()), null);
1793 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1794 TaxonNode node
=nodes
.next();
1795 testTaxon
.addMisappliedName(misappliedName
, null, null);
1796 UUID misappliedNameUUID
= service
.save(misappliedName
).getUuid();
1798 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1799 config
.setDeleteMisappliedNames(false);
1801 DeleteResult result
= service
.deleteTaxon(testTaxon
.getUuid(), config
, node
.getClassification().getUuid());
1805 commitAndStartNewTransaction(null);
1806 Taxon tax
= (Taxon
)service
.find(uuid
);
1808 tax
= (Taxon
)service
.find(misappliedNameUUID
);
1809 //TODO: is that correct or should it be deleted because there is no relation to anything
1814 @DataSet(value
="../../database/ClearDBDataSet.xml")
1815 public final void testTaxonDeletionConfiguratorTaxonMisappliedName(){
1817 Taxon testTaxon
= getTestTaxon();
1818 UUID uuid
= service
.save(testTaxon
).getUuid();
1820 Taxon misappliedNameTaxon
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(Rank
.GENUS()), null);
1822 Iterator
<TaxonNode
> nodes
= testTaxon
.getTaxonNodes().iterator();
1823 TaxonNode node
=nodes
.next();
1824 testTaxon
.addMisappliedName(misappliedNameTaxon
, null, null);
1825 UUID misappliedNameUUID
= service
.save(misappliedNameTaxon
).getUuid();
1826 misappliedNameTaxon
= (Taxon
)service
.find(misappliedNameUUID
);
1827 UUID misNameUUID
= misappliedNameTaxon
.getName().getUuid();
1829 TaxonDeletionConfigurator config
= new TaxonDeletionConfigurator() ;
1831 service
.deleteTaxon(misappliedNameTaxon
.getUuid(), config
,null);
1833 commitAndStartNewTransaction(null);
1834 Taxon tax
= (Taxon
)service
.find(uuid
);
1836 tax
= (Taxon
)service
.find(misappliedNameUUID
);
1837 IBotanicalName name
= nameService
.find(misNameUUID
);
1844 @DataSet(value
="../../database/ClearDBDataSet.xml")
1845 public final void testListIncludedTaxa(){
1846 Reference citation
= null;
1847 String microcitation
= null;
1850 Classification cl1
= Classification
.NewInstance("testClassification1");
1851 Classification cl2
= Classification
.NewInstance("testClassification2");
1852 Classification cl3
= Classification
.NewInstance("testClassification3");
1854 classificationService
.save(cl1
);
1855 classificationService
.save(cl2
);
1856 classificationService
.save(cl3
);
1858 Taxon c1Genus
= Taxon
.NewInstance(null, null);c1Genus
.setUuid(UUID
.fromString("daa24f6f-7e38-4668-b385-10c789212e4e"));
1859 Taxon c1Species
= Taxon
.NewInstance(null, null);c1Species
.setUuid(UUID
.fromString("1c1d0566-67d0-4806-bf23-ecf55f4b9118"));
1860 Taxon c1SubSpecies1
= Taxon
.NewInstance(null, null);c1SubSpecies1
.setUuid(UUID
.fromString("96ae2fad-76df-429f-b179-42e00838fea4"));
1861 Taxon c1SubSpecies2
= Taxon
.NewInstance(null, null);c1SubSpecies2
.setUuid(UUID
.fromString("5d3f6147-ca72-40e0-be8a-6c835a09a579"));
1862 TaxonNode c1childNodeSpecies1
= cl1
.addParentChild(c1Genus
, c1Species
, null, null);
1863 nodeService
.saveOrUpdate(c1childNodeSpecies1
.getParent());
1864 nodeService
.saveOrUpdate(c1childNodeSpecies1
);
1865 TaxonNode c1childNodeSubSpecies1
=cl1
.addParentChild(c1Species
, c1SubSpecies1
, null, null);
1866 nodeService
.saveOrUpdate(c1childNodeSubSpecies1
);
1867 TaxonNode c1childNodeSubSpecies2
=cl1
.addParentChild(c1Species
, c1SubSpecies2
, null, null);
1868 nodeService
.saveOrUpdate(c1childNodeSubSpecies2
);
1870 Taxon c2Genus
= Taxon
.NewInstance(null, null);c2Genus
.setUuid(UUID
.fromString("ed0ec006-3ac8-4a12-ae13-fdf2a13dedbe"));
1871 Taxon c2Species
= Taxon
.NewInstance(null, null);c2Species
.setUuid(UUID
.fromString("1027eb18-1c26-450e-a299-981b775ebc3c"));
1872 Taxon c2SubSpecies1
= Taxon
.NewInstance(null, null);c2SubSpecies1
.setUuid(UUID
.fromString("61f039c8-01f3-4f5d-8e16-1602139774e7"));
1873 Taxon c2SubSpecies2
= Taxon
.NewInstance(null, null);c2SubSpecies2
.setUuid(UUID
.fromString("2ed6b6f8-05f9-459a-a075-2bca57e3013e"));
1874 TaxonNode c2childNodeSpecies1
= cl2
.addParentChild(c2Genus
, c2Species
, null, null);
1875 nodeService
.saveOrUpdate(c2childNodeSpecies1
.getParent());
1876 nodeService
.saveOrUpdate(c2childNodeSpecies1
);
1877 TaxonNode c2childNodeSubSpecies1
= cl2
.addParentChild(c2Species
, c2SubSpecies1
, null, null);
1878 nodeService
.saveOrUpdate(c2childNodeSubSpecies1
);
1879 TaxonNode c2childNodeSubSpecies2
= cl2
.addParentChild(c2Species
, c2SubSpecies2
, null, null);
1880 nodeService
.saveOrUpdate(c2childNodeSubSpecies2
);
1882 Taxon c3Genus
= Taxon
.NewInstance(null, null);c3Genus
.setUuid(UUID
.fromString("407dfc8d-7a4f-4370-ada4-76c1a8279d1f"));
1883 Taxon c3Species
= Taxon
.NewInstance(null, null);c3Species
.setUuid(UUID
.fromString("b6d34fc7-4aa7-41e5-b633-86f474edbbd5"));
1884 Taxon c3SubSpecies1
= Taxon
.NewInstance(null, null);c3SubSpecies1
.setUuid(UUID
.fromString("01c07585-a422-40cd-9339-a74c56901d9f"));
1885 Taxon c3SubSpecies2
= Taxon
.NewInstance(null, null);c3SubSpecies2
.setUuid(UUID
.fromString("390c8e23-e05f-4f89-b417-50cf080f4c91"));
1886 TaxonNode c3childNodeSpecies1
= cl3
.addParentChild(c3Genus
, c3Species
, null, null);
1887 nodeService
.saveOrUpdate(c3childNodeSpecies1
.getParent());
1888 nodeService
.saveOrUpdate(c3childNodeSpecies1
);
1889 TaxonNode c3childNodeSubSpecies1
= cl3
.addParentChild(c3Species
, c3SubSpecies1
, null, null);
1890 nodeService
.saveOrUpdate(c3childNodeSubSpecies1
);
1891 TaxonNode c3childNodeSubSpecies2
= cl3
.addParentChild(c3Species
, c3SubSpecies2
, null, null);
1892 nodeService
.saveOrUpdate(c3childNodeSubSpecies2
);
1894 Taxon c4Genus
= Taxon
.NewInstance(null, null);c4Genus
.setUuid(UUID
.fromString("bfd6bbdd-0116-4ab2-a781-9316224aad78"));
1895 Taxon c4Species
= Taxon
.NewInstance(null, null);c4Species
.setUuid(UUID
.fromString("9347a3d9-5ece-4d64-9035-e8aaf5d3ee02"));
1896 Taxon c4SubSpecies
= Taxon
.NewInstance(null, null);c4SubSpecies
.setUuid(UUID
.fromString("777aabbe-4c3a-449c-ab99-a91f2fec9f07"));
1898 TaxonRelationship rel
= c1Species
.addTaxonRelation(c2Species
, TaxonRelationshipType
.CONGRUENT_TO(), citation
, microcitation
);
1899 rel
.setDoubtful(true);
1900 c1Species
.addTaxonRelation(c4Species
, TaxonRelationshipType
.INCLUDES(), citation
, microcitation
);
1901 c2Species
.addTaxonRelation(c1SubSpecies2
, TaxonRelationshipType
.INCLUDES(), citation
, microcitation
);
1903 service
.saveOrUpdate(c1Species
);
1904 service
.saveOrUpdate(c2Species
);
1905 service
.save(c4Species
);
1906 commitAndStartNewTransaction();
1909 //default starting at species 1
1910 IncludedTaxaDTO dto
= service
.listIncludedTaxa(c1Species
.getUuid(), new IncludedTaxonConfiguration(null, true, false));
1911 Assert
.assertNotNull("IncludedTaxaDTO", dto
);
1912 Assert
.assertEquals("Result should contain 7 taxa: c1Species", 7, dto
.getIncludedTaxa().size());
1913 Assert
.assertNotNull("date should not be null", dto
.getDate());
1914 // Assert.assertTrue(dto.contains(taxonUuid));
1915 //same without doubtful
1916 dto
= service
.listIncludedTaxa(c1Species
.getUuid(), new IncludedTaxonConfiguration(null, false, false));
1917 Assert
.assertEquals(4, dto
.getIncludedTaxa().size());
1919 //other example starting at Genus2
1920 dto
= service
.listIncludedTaxa(c2Genus
.getUuid(), new IncludedTaxonConfiguration(null, true, false));
1921 Assert
.assertEquals(8, dto
.getIncludedTaxa().size());
1922 //same without doubtful
1923 dto
= service
.listIncludedTaxa(c2Genus
.getUuid(), new IncludedTaxonConfiguration(null, false, false));
1924 Assert
.assertEquals(5, dto
.getIncludedTaxa().size());
1927 dto
= service
.listIncludedTaxa(c1Species
.getUuid(), new IncludedTaxonConfiguration(null, true, true));
1928 Assert
.assertEquals(2, dto
.getIncludedTaxa().size());
1929 //same without doubtful
1930 dto
= service
.listIncludedTaxa(c1Species
.getUuid(), new IncludedTaxonConfiguration(null, false, true));
1931 Assert
.assertEquals(1, dto
.getIncludedTaxa().size());
1935 public void testDeleteDescriptions(){
1937 createTestDataSet();
1938 } catch (FileNotFoundException e
) {
1939 // TODO Auto-generated catch block
1940 e
.printStackTrace();
1942 TaxonDescription description
= TaxonDescription
.NewInstance(taxWithoutSyn
);
1943 SpecimenOrObservationBase
<IIdentifiableEntityCacheStrategy
<FieldUnit
>> specimen
= FieldUnit
.NewInstance();
1944 UUID uuid
= occurenceService
.saveOrUpdate(specimen
);
1945 DescriptionElementBase element
= IndividualsAssociation
.NewInstance(specimen
);
1946 description
.addElement(element
);
1947 service
.saveOrUpdate(taxWithoutSyn
);
1950 Taxon tax
= (Taxon
)service
.find(uuidTaxWithoutSyn
);
1951 Set
<TaxonDescription
> descr
= tax
.getDescriptions();
1952 assertEquals(1, descr
.size());
1953 description
= descr
.iterator().next();
1954 UUID uuidDescr
= description
.getUuid();
1955 UUID uuidDescEl
= description
.getElements().iterator().next().getUuid();
1957 descriptionService
.deleteDescription(description
);
1958 service
.saveOrUpdate(tax
);
1960 description
= (TaxonDescription
) descriptionService
.find(uuidDescr
);
1961 specimen
= occurenceService
.find(uuid
);
1962 assertNull(description
);
1963 DeleteResult result
= occurenceService
.delete(specimen
);
1964 assertTrue(result
.isOk());
1969 public void testRemoveDescriptionsFromTaxa(){
1971 createTestDataSet();
1972 } catch (FileNotFoundException e
) {
1973 // TODO Auto-generated catch block
1974 e
.printStackTrace();
1976 TaxonDescription description
= TaxonDescription
.NewInstance(taxWithoutSyn
);
1977 SpecimenOrObservationBase
<IIdentifiableEntityCacheStrategy
<FieldUnit
>> specimen
= FieldUnit
.NewInstance();
1978 UUID uuid
= occurenceService
.saveOrUpdate(specimen
);
1979 DescriptionElementBase element
= IndividualsAssociation
.NewInstance(specimen
);
1980 description
.addElement(element
);
1981 service
.saveOrUpdate(taxWithoutSyn
);
1984 Taxon tax
= (Taxon
)service
.find(uuidTaxWithoutSyn
);
1985 Set
<TaxonDescription
> descr
= tax
.getDescriptions();
1986 assertEquals(1, descr
.size());
1987 description
= descr
.iterator().next();
1988 UUID uuidDescr
= description
.getUuid();
1991 tax
.removeDescription(description
, true);
1992 service
.saveOrUpdate(tax
);
1994 description
= (TaxonDescription
) descriptionService
.find(uuidDescr
);
1995 specimen
= occurenceService
.find(uuid
);
1996 assertNotNull(description
);
1997 DeleteResult result
= occurenceService
.delete(specimen
);
1998 assertTrue(result
.isOk());
2002 @DataSet(loadStrategy
=CleanSweepInsertLoadStrategy
.class, value
="ClearDBDataSet.xml")
2003 public void createTestDataSet() throws FileNotFoundException
{
2004 Rank rank
= Rank
.SPECIES();
2005 taxWithoutSyn
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test1", null, null, null, null, null, null, null), null);
2006 taxWithSyn
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test3", null, null, null, null, null, null, null), null);
2007 tax2WithSyn
= Taxon
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test5", null, null, null, null, null, null, null), null);
2008 synonym
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test2", null, null, null, null, null, null, null), null);
2009 synonym2
= Synonym
.NewInstance(TaxonNameFactory
.NewBotanicalInstance(rank
, "Test4", null, null, null, null, null, null, null), null);
2010 synonym2
.getName().setHomotypicalGroup(synonym
.getHomotypicGroup());
2012 taxWithSyn
.addSynonym(synonym
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
2013 taxWithSyn
.addSynonym(synonym2
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
2015 uuidTaxWithoutSyn
= service
.save(taxWithoutSyn
).getUuid();
2016 uuidSyn
= service
.save(synonym
).getUuid();
2017 uuidSyn2
= service
.save(synonym2
).getUuid();
2018 uuidTaxWithSyn
=service
.save(taxWithSyn
).getUuid();
2022 //public static UUID DESCRIPTION1_UUID = UUID.fromString("f3e061f6-c5df-465c-a253-1e18ab4c7e50");
2023 //public static UUID DESCRIPTION2_UUID = UUID.fromString("1b009a40-ebff-4f7e-9f7f-75a850ba995d");
2025 public Taxon
getTestTaxon(){
2026 int descrIndex
= 6000;
2027 Person deCandolle
= Person
.NewInstance();
2028 deCandolle
.setTitleCache("DC.", true);
2030 Reference sec
= ReferenceFactory
.newDatabase();
2031 sec
.setTitleCache("Flora lunaea", true);
2032 Reference citationRef
= ReferenceFactory
.newBook();
2033 citationRef
.setTitleCache("Sp. lunarum", true);
2035 //genus taxon with Name, combinationAuthor,
2036 IBotanicalName botName
= TaxonNameFactory
.NewBotanicalInstance(Rank
.GENUS());
2037 botName
.setTitleCache("Hieracium L.", true);
2038 botName
.setGenusOrUninomial("Hieracium");
2039 botName
.setCombinationAuthorship(Person
.NewInstance());
2040 botName
.getCombinationAuthorship().setNomenclaturalTitle("L.");
2041 botName
.setUuid(GENUS_NAME_UUID
);
2042 Taxon genusTaxon
= Taxon
.NewInstance(botName
, sec
);
2043 genusTaxon
.setUuid(GENUS_UUID
);
2044 service
.save(genusTaxon
);
2045 //a name that is the basionym of genusTaxon's name
2046 TaxonName basionym
= TaxonNameFactory
.NewBotanicalInstance(Rank
.GENUS());
2047 basionym
.setTitleCache("Hieracilla DC.", true);
2048 basionym
.setGenusOrUninomial("Hieracilla");
2049 basionym
.setCombinationAuthorship(deCandolle
);
2050 basionym
.setUuid(BASIONYM_UUID
);
2051 botName
.addBasionym(basionym
, null, null,"216", null);
2052 nameService
.saveOrUpdate(basionym
);
2053 //species taxon that is the child of genus taxon
2054 IBotanicalName botSpecies
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
2055 botSpecies
.setTitleCache("Hieracium asturianum Pau", true);
2056 botSpecies
.setGenusOrUninomial("Hieracium");
2057 botSpecies
.setSpecificEpithet("asturianum");
2058 botSpecies
.setCombinationAuthorship(Person
.NewInstance());
2059 botSpecies
.getCombinationAuthorship().setNomenclaturalTitle("Pau");
2060 botSpecies
.setUuid(SPECIES1_NAME_UUID
);
2061 Taxon childTaxon
= Taxon
.NewInstance(botSpecies
, sec
);
2062 childTaxon
.setUuid(SPECIES1_UUID
);
2063 TaxonDescription taxDesc
= getTestDescription(descrIndex
++);
2064 //taxDesc.setUuid(DESCRIPTION1_UUID);
2065 childTaxon
.addDescription(taxDesc
);
2066 service
.saveOrUpdate(childTaxon
);
2067 Classification classification
= getTestClassification("TestClassification");
2068 classification
.addParentChild(genusTaxon
, childTaxon
, citationRef
, "456");
2069 // childTaxon.setTaxonomicParent(genusTaxon, citationRef, "456");
2070 classificationService
.save(classification
);
2071 //homotypic synonym of childTaxon1
2072 IBotanicalName botSpecies4
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
2073 botSpecies4
.setTitleCache("Hieracium gueri DC.", true);
2074 botSpecies4
.setGenusOrUninomial("Hieracium");
2075 botSpecies4
.setSpecificEpithet("gueri");
2076 botSpecies4
.setCombinationAuthorship(deCandolle
);
2077 botSpecies4
.setUuid(SYNONYM_NAME_UUID
);
2078 Synonym homoSynonym
= Synonym
.NewInstance(botSpecies4
, sec
);
2080 childTaxon
.addSynonym(homoSynonym
, SynonymType
.HOMOTYPIC_SYNONYM_OF());
2081 service
.saveOrUpdate(childTaxon
);
2083 //2nd child species taxon that is the child of genus taxon
2084 IBotanicalName botSpecies2
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
2085 botSpecies2
.setTitleCache("Hieracium wolffii Zahn", true);
2086 botSpecies2
.setGenusOrUninomial("Hieracium");
2087 botSpecies2
.setSpecificEpithet("wolffii");
2088 botSpecies2
.setCombinationAuthorship(Person
.NewInstance());
2089 botSpecies2
.getCombinationAuthorship().setNomenclaturalTitle("Zahn");
2090 botSpecies2
.setUuid(SPECIES2_NAME_UUID
);
2091 Taxon childTaxon2
= Taxon
.NewInstance(botSpecies2
, sec
);
2092 childTaxon2
.setUuid(SPECIES2_UUID
);
2093 classification
.addParentChild(genusTaxon
, childTaxon2
, citationRef
, "499");
2094 //childTaxon2.setTaxonomicParent(genusTaxon, citationRef, "499");
2095 service
.saveOrUpdate(childTaxon2
);
2096 //heterotypic synonym of childTaxon2
2097 IBotanicalName botSpecies3
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
2098 botSpecies3
.setTitleCache("Hieracium lupium DC.", true);
2099 botSpecies3
.setGenusOrUninomial("Hieracium");
2100 botSpecies3
.setSpecificEpithet("lupium");
2101 botSpecies3
.setCombinationAuthorship(deCandolle
);
2102 botSpecies3
.setUuid(SYNONYM2_NAME_UUID
);
2103 Synonym heteroSynonym
= Synonym
.NewInstance(botSpecies3
, sec
);
2104 heteroSynonym
.setUuid(SYNONYM2_UUID
);
2105 childTaxon2
.addSynonym(heteroSynonym
, SynonymType
.HETEROTYPIC_SYNONYM_OF());
2106 service
.saveOrUpdate(childTaxon2
);
2107 //missaplied Name for childTaxon2
2108 IBotanicalName missName
= TaxonNameFactory
.NewBotanicalInstance(Rank
.SPECIES());
2109 missName
.setTitleCache("Hieracium lupium DC.", true);
2110 missName
.setGenusOrUninomial("Hieracium");
2111 missName
.setSpecificEpithet("lupium");
2112 missName
.setCombinationAuthorship(deCandolle
);
2113 missName
.setUuid(SPECIES5_NAME_UUID
);
2114 Taxon misappliedNameTaxon
= Taxon
.NewInstance(missName
, sec
);
2115 childTaxon2
.addMisappliedName(misappliedNameTaxon
, citationRef
, "125");
2116 taxDesc
= getTestDescription(descrIndex
++);
2117 // taxDesc.setUuid(DESCRIPTION2_UUID);
2118 genusTaxon
.addDescription(taxDesc
);
2119 service
.saveOrUpdate(genusTaxon
);
2120 service
.save(misappliedNameTaxon
);
2125 public TaxonDescription
getTestDescription(int index
){
2126 TaxonDescription taxonDescription
= TaxonDescription
.NewInstance();
2127 Language language
= Language
.DEFAULT();
2128 //taxonDescription.setId(index);
2131 TextData textData
= TextData
.NewInstance();
2132 String descriptionText
= "this is a desciption for a taxon";
2133 LanguageString languageString
= LanguageString
.NewInstance(descriptionText
, language
);
2134 textData
.putText(languageString
);
2135 taxonDescription
.addElement(textData
);
2139 String commonNameString
= "Schönveilchen";
2140 CommonTaxonName commonName
= CommonTaxonName
.NewInstance(commonNameString
, language
);
2141 taxonDescription
.addElement(commonName
);
2143 return taxonDescription
;
2146 public Classification
getTestClassification(String name
){
2147 return Classification
.NewInstance(name
);