import static org.junit.Assert.assertEquals;\r
import static org.junit.Assert.assertNotNull;\r
import static org.junit.Assert.assertNull;\r
+import static org.junit.Assert.assertTrue;\r
\r
-import java.io.IOException;\r
-import java.net.URISyntaxException;\r
-import java.sql.SQLException;\r
+import java.io.FileNotFoundException;\r
+import java.util.ArrayList;\r
+import java.util.Iterator;\r
import java.util.List;\r
import java.util.Set;\r
import java.util.UUID;\r
\r
import org.apache.log4j.Logger;\r
-import org.dbunit.DatabaseUnitException;\r
import org.junit.Assert;\r
-import org.junit.Ignore;\r
-import org.junit.Before;\r
import org.junit.Test;\r
import org.unitils.dbunit.annotation.DataSet;\r
-import org.unitils.dbunit.datasetfactory.DataSetFactory;\r
import org.unitils.spring.annotation.SpringBeanByType;\r
\r
+import eu.etaxonomy.cdm.api.service.config.IncludedTaxonConfiguration;\r
+import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;\r
+import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;\r
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;\r
+import eu.etaxonomy.cdm.api.service.config.TaxonNodeDeletionConfigurator.ChildHandling;\r
+import eu.etaxonomy.cdm.api.service.dto.IncludedTaxaDTO;\r
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;\r
-import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;\r
+import eu.etaxonomy.cdm.datagenerator.TaxonGenerator;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
+import eu.etaxonomy.cdm.model.common.Extension;\r
+import eu.etaxonomy.cdm.model.common.IdentifiableSource;\r
+import eu.etaxonomy.cdm.model.common.Marker;\r
+import eu.etaxonomy.cdm.model.common.MarkerType;\r
+import eu.etaxonomy.cdm.model.common.OriginalSourceType;\r
+import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
+import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
+import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;\r
+import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;\r
+import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;\r
+import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
import eu.etaxonomy.cdm.model.taxon.Classification;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
+import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
+import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
+import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;\r
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;\r
import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;\r
\r
/**\r
* @author a.mueller\r
- *\r
*/\r
+\r
+\r
public class TaxonServiceImplTest extends CdmTransactionalIntegrationTest {\r
private static final Logger logger = Logger.getLogger(TaxonServiceImplTest.class);\r
\r
@SpringBeanByType\r
private IClassificationService classificationService;\r
\r
+ @SpringBeanByType\r
+ private ITaxonNodeService nodeService;\r
+\r
+ @SpringBeanByType\r
+ private IDescriptionService descriptionService;\r
+ \r
+ @SpringBeanByType\r
+ private IMarkerService markerService;\r
+\r
+ @SpringBeanByType\r
+ private IEventBaseService eventService;\r
+ \r
+ @SpringBeanByType\r
+ private IOccurrenceService occurenceService;\r
+\r
+\r
\r
/****************** TESTS *****************************/\r
\r
\r
- /**\r
+ /**\r
* Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.\r
*/\r
@Test\r
*/\r
@Test\r
public final void testRemoveTaxon() {\r
- Taxon taxon = Taxon.NewInstance(BotanicalName.NewInstance(null), null);\r
+ Taxon taxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.UNKNOWN_RANK()), null);\r
UUID uuid = service.save(taxon);\r
- service.delete(taxon);\r
+ // try {\r
+ service.deleteTaxon(taxon, null, null);\r
+ /*} catch (DataChangeNoRollbackException e) {\r
+ // TODO Auto-generated catch block\r
+ e.printStackTrace();\r
+ }*/\r
TaxonBase<?> actualTaxon = service.find(uuid);\r
assertNull(actualTaxon);\r
}\r
\r
-// @Test\r
-// @DataSet("ClearDBDataSet.xml")\r
-// public final void clearDataBase() {\r
-//\r
-// setComplete();\r
-// commitAndStartNewTransaction(null);\r
-//\r
-// logger.info("DataBase tables cleared");\r
-// }\r
-\r
-\r
-// @Test\r
- public final void testPrintDataSet() {\r
-//\r
-// printDataSet(System.out);\r
-// printDataSet(System.err, new String[] {"TAXONNODE", "AgentBase"});\r
-// printTableNames(System.err, "<%1$s />");\r
-// System.exit(0);\r
-\r
- }\r
\r
@Test\r
public final void testMakeTaxonSynonym() {\r
// find forces flush\r
TaxonBase<?> tax = service.find(uuidTaxon);\r
TaxonBase<?> syn = service.find(uuidSyn);\r
+\r
+ assertTrue(tax.getName().getTitleCache().equals("Test2"));\r
+\r
HomotypicalGroup groupTest = tax.getHomotypicGroup();\r
HomotypicalGroup groupTest2 = syn.getHomotypicGroup();\r
assertEquals(groupTest, groupTest2);\r
+ \r
}\r
\r
- //@Test\r
+ @Test\r
public final void testChangeSynonymToAcceptedTaxon(){\r
Rank rank = Rank.SPECIES();\r
//HomotypicalGroup group = HomotypicalGroup.NewInstance();\r
service.save(taxWithoutSyn);\r
UUID uuidSyn = service.save(synonym);\r
service.save(synonym2);\r
- service.save(taxWithSyn);\r
+ UUID uuidTaxWithSyn =service.save(taxWithSyn);\r
\r
Taxon taxon = null;\r
try {\r
} catch (HomotypicalGroupChangeException e) {\r
Assert.fail("Invocation of change method should not throw an exception");\r
}\r
+ taxWithSyn = null;\r
//test flush (resave deleted object)\r
TaxonBase<?> syn = service.find(uuidSyn);\r
+ taxWithSyn = (Taxon)service.find(uuidTaxWithSyn);\r
+ Taxon taxNew = (Taxon)service.find(taxon.getUuid());\r
assertNull(syn);\r
+ assertNotNull(taxWithSyn);\r
+ assertNotNull(taxNew);\r
+\r
Assert.assertEquals("New taxon should have 1 synonym relationship (the old homotypic synonym)", 1, taxon.getSynonymRelations().size());\r
}\r
\r
\r
+\r
+ @Test\r
+ public final void testChangeSynonymToAcceptedTaxonSynonymForTwoTaxa(){\r
+ Rank rank = Rank.SPECIES();\r
+ //HomotypicalGroup group = HomotypicalGroup.NewInstance();\r
+ Taxon taxWithoutSyn = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test1", null, null, null, null, null, null, null), null);\r
+ Taxon tax2WithSyn = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test5", null, null, null, null, null, null, null), null);\r
+ Taxon taxWithSyn = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test3", null, null, null, null, null, null, null), null);\r
+ Synonym synonym = Synonym.NewInstance(BotanicalName.NewInstance(rank, "Test2", null, null, null, null, null, null, null), null);\r
+ Synonym synonym2 = Synonym.NewInstance(BotanicalName.NewInstance(rank, "Test4", null, null, null, null, null, null, null), null);\r
+ //synonym2.getName().setHomotypicalGroup(taxWithSyn.getHomotypicGroup());\r
+ //tax2.addHeterotypicSynonymName(synonym.getName());\r
+ taxWithSyn.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+ taxWithSyn.addSynonym(synonym2, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\r
+ tax2WithSyn.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+\r
+ service.save(taxWithoutSyn);\r
+\r
+ UUID uuidSyn = service.save(synonym);\r
+ service.save(synonym2);\r
+ UUID uuidTaxWithSyn =service.save(taxWithSyn);\r
+ service.save(tax2WithSyn);\r
+\r
+\r
+ Taxon taxon = null;\r
+ try {\r
+ taxon = service.changeSynonymToAcceptedTaxon(synonym, taxWithSyn, true, true, null, null);\r
+ service.save(taxon);\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ Assert.fail("Invocation of change method should not throw an exception");\r
+ }\r
+ taxWithSyn = null;\r
+ tax2WithSyn = null;\r
+\r
+ //test flush (resave deleted object)\r
+ TaxonBase<?> syn = service.find(uuidSyn);\r
+ taxWithSyn = (Taxon)service.find(uuidTaxWithSyn);\r
+ Taxon taxNew = (Taxon)service.find(taxon.getUuid());\r
+ assertNotNull(syn);\r
+ assertNotNull(taxWithSyn);\r
+ assertNotNull(taxNew);\r
+\r
+ // Assert.assertEquals("New taxon should have 1 synonym relationship (the old homotypic synonym)", 1, taxon.getSynonymRelations().size());\r
+ }\r
+\r
/**\r
* Old implementation taken from {@link TaxonServiceImplBusinessTest} for old version of method.\r
* Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#moveSynonymToAnotherTaxon(eu.etaxonomy.cdm.model.taxon.SynonymRelationship, eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)}.\r
Assert.fail("Move of single heterotypic synonym should not throw exception: " + e.getMessage());\r
}\r
//Asserts\r
- //FIXME thows exception\r
+ //FIXME throws exception\r
commitAndStartNewTransaction(tableNames);\r
\r
// printDataSet(System.err, new String[]{"AgentBase", "TaxonBase"});\r
//\r
// printDataSet(System.err, new String[]{"TaxonBase"});\r
\r
- heterotypicSynonym = (Synonym)service.load(uuidSyn5);\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn5);\r
\r
- printDataSet(System.err, new String[]{"TaxonBase"});\r
+// printDataSet(System.err, new String[]{"TaxonBase"});\r
// System.exit(0);\r
\r
- Assert.assertNotNull("Synonym should still exist", heterotypicSynonym);\r
+ Assert.assertNotNull("Synonym should still exist", heterotypicSynonym);\r
Assert.assertEquals("Synonym should still have 1 relation", 1, heterotypicSynonym.getSynonymRelations().size());\r
rel = heterotypicSynonym.getSynonymRelations().iterator().next();\r
Assert.assertEquals("Accepted taxon of single relation should be new taxon", newTaxon, rel.getAcceptedTaxon());\r
//test single heterotypic synonym to homotypic synonym of new taxon\r
//+ new reference\r
newTaxon = (Taxon)service.load(uuidNewTaxon);\r
- Reference<?> ref2 = (Reference<?>)referenceService.load(uuidRef2);\r
+ Reference<?> ref2 = referenceService.load(uuidRef2);\r
heterotypicSynonym = (Synonym)service.load(uuidSyn6);\r
Assert.assertNotNull("Synonym should exist", heterotypicSynonym);\r
Assert.assertEquals("Synonym should have 1 relation", 1, heterotypicSynonym.getSynonymRelations().size());\r
\r
@Test\r
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
- public final void testDeleteSynonymSynonymTaxonBoolean(){\r
+ //test delete synonym, but the name will not be deleted\r
+ public final void testDeleteSynonymSynonymTaxonDontDeleteName(){\r
final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
"SynonymRelationship","SynonymRelationship_AUD",\r
"HomotypicalGroup","HomotypicalGroup_AUD"};\r
-// BotanicalName taxonName1 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// taxonName1.setTitleCache("TaxonName1",true);\r
-// BotanicalName taxonName2 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// taxonName2.setTitleCache("TaxonName2",true);\r
-// BotanicalName synonymName1 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// synonymName1.setTitleCache("Synonym1",true);\r
-// BotanicalName synonymName2 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// synonymName2.setTitleCache("Synonym2",true);\r
-//\r
-// Reference<?> sec = null;\r
-// Taxon taxon1 = Taxon.NewInstance(taxonName1, sec);\r
-// Taxon taxon2 = Taxon.NewInstance(taxonName2, sec);\r
-// Synonym synonym1 = Synonym.NewInstance(synonymName1, sec);\r
-// Synonym synonym2 = Synonym.NewInstance(synonymName2, sec);\r
-//\r
-// SynonymRelationship rel1 = taxon1.addSynonym(synonym1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
-// SynonymRelationship rel = taxon2.addSynonym(synonym1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
-// rel.setProParte(true);\r
-// rel1.setProParte(true);\r
-//\r
-// service.save(taxon1);\r
-// service.save(synonym2);\r
-//\r
-// this.setComplete();\r
-// this.endTransaction();\r
-//\r
-//\r
+\r
int nSynonyms = service.count(Synonym.class);\r
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
int nNames = nameService.count(TaxonNameBase.class);\r
Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
+ \r
\r
-// UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");\r
-// UUID uuidTaxon2=UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");\r
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
-// UUID uuidSynonym2=UUID.fromString("f8d86dc9-5f18-4877-be46-fbb9412465e4");\r
+\r
\r
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
- service.deleteSynonym(synonym1, null, true, true);\r
+ SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();\r
+ config.setDeleteNameIfPossible(false);\r
+ config.setNewHomotypicGroupIfNeeded(true);\r
+ service.deleteSynonym(synonym1, config);\r
\r
this.commitAndStartNewTransaction(tableNames);\r
\r
nSynonyms = service.count(Synonym.class);\r
Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);\r
nNames = nameService.count(TaxonNameBase.class);\r
- Assert.assertEquals("There should be 3 names left in the database", 3, nNames);\r
+ Assert.assertEquals("There should be 4 names left in the database", 4, nNames);\r
int nRelations = service.countAllRelationships();\r
Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);\r
}\r
\r
@Test\r
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ //test delete synonym and his name\r
+ public final void testDeleteSynonymSynonymTaxonDeleteName(){\r
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
+ "SynonymRelationship","SynonymRelationship_AUD",\r
+ "HomotypicalGroup","HomotypicalGroup_AUD"};\r
+\r
+ int nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
+ int nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
+ int nRelations = service.countAllRelationships();\r
+\r
+ UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
+\r
+\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
+ service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
+\r
+ this.commitAndStartNewTransaction(tableNames);\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 3 names left in the database", 3, nNames);\r
+ nRelations = service.countAllRelationships();\r
+ Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);\r
+ \r
+ }\r
+\r
+ @Test\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ //test remove synonym from taxon -> synonym and name still in the db and the synonymrelationship to the other taxon\r
+ //test delete synonym -> all relationships are deleted, the name is deleted and the synonym itself\r
public final void testDeleteSynonymSynonymTaxonBooleanRelToOneTaxon(){\r
final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
"SynonymRelationship","SynonymRelationship_AUD",\r
UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");\r
UUID uuidTaxon2=UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");\r
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
-// UUID uuidSynonym2=UUID.fromString("f8d86dc9-5f18-4877-be46-fbb9412465e4");\r
\r
- Taxon taxon2 = (Taxon)service.load(uuidTaxon2);\r
\r
-\r
- Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
+ Taxon taxon2 = (Taxon)service.load(uuidTaxon2);\r
+ \r
+ List<String> initStrat = new ArrayList<String>();\r
+ initStrat.add("markers");\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1, initStrat);\r
\r
taxon2.removeSynonym(synonym1, false);\r
service.saveOrUpdate(taxon2);\r
Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
int nRelations = service.countAllRelationships();\r
Assert.assertEquals("There should be 1 relationship left in the database", 1, nRelations);\r
-\r
- taxon2 = (Taxon)service.load(uuidTaxon2);\r
+ Marker marker1 = Marker.NewInstance(MarkerType.IMPORTED(), true);\r
+ Marker marker2 = Marker.NewInstance(MarkerType.COMPUTED(), true);\r
+ synonym1.addMarker(marker1);\r
+ synonym1.addMarker(marker2);\r
+ service.update(synonym1);\r
+ synonym1 =(Synonym) service.load(uuidSynonym1);\r
+ \r
+ \r
+ Set<Marker> markers = synonym1.getMarkers();\r
+ Marker marker = markers.iterator().next();\r
+ UUID markerUUID = marker.getUuid();\r
+ // taxon2 = (Taxon)service.load(uuidTaxon2);\r
synonym1 = (Synonym)service.load(uuidSynonym1);\r
-\r
- service.deleteSynonym(synonym1, null, true, true);\r
-\r
+ //the marker should not prevent the deletion\r
+ DeleteResult result = service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ \r
+ \r
+ \r
+ \r
commitAndStartNewTransaction(tableNames);\r
-\r
nSynonyms = service.count(Synonym.class);\r
Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);\r
nNames = nameService.count(TaxonNameBase.class);\r
Assert.assertEquals("There should be 3 names left in the database", 3, nNames);\r
nRelations = service.countAllRelationships();\r
Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);\r
+ marker = markerService.load(markerUUID);\r
+ assertNull(marker);\r
\r
}\r
\r
@Test\r
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ //test delete synonym, only for a special taxon, but because of other relationships it will not be deleted at all\r
public final void testDeleteSynonymSynonymTaxonBooleanDeleteOneTaxon(){\r
final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
"SynonymRelationship","SynonymRelationship_AUD",\r
"HomotypicalGroup","HomotypicalGroup_AUD"};\r
\r
-// printDataSet(System.err, new String[]{"TaxonNode"});\r
-\r
\r
int nSynonyms = service.count(Synonym.class);\r
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
Taxon taxon1 = (Taxon)service.load(uuidTaxon1);\r
Taxon taxon2 = (Taxon)service.load(uuidTaxon2);\r
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
-\r
- service.deleteSynonym(synonym1, taxon1, true, true);\r
+ synonym1.addExtension(Extension.NewInstance());\r
+ service.saveOrUpdate(synonym1);\r
+ \r
+ service.deleteSynonym(synonym1, taxon1, new SynonymDeletionConfigurator());\r
\r
this.commitAndStartNewTransaction(tableNames);\r
\r
Assert.assertEquals("There should be 4 names left in the database (name not deleted as synonym was not deleted)", 4, nNames);\r
int nRelations = service.countAllRelationships();\r
Assert.assertEquals("There should be 1 relationship left in the database", 1, nRelations);\r
-\r
+ \r
+ \r
}\r
\r
@Test\r
@DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")\r
+\r
public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedName(){\r
final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
"SynonymRelationship","SynonymRelationship_AUD",\r
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");\r
\r
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
- TaxonNameBase name2 = (TaxonNameBase)nameService.load(uuidSynonymName2);\r
- synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
+ TaxonNameBase name2 = nameService.load(uuidSynonymName2);\r
+ UUID name3Uuid = synonym1.getName().getUuid();\r
+ TaxonNameBase name3 = nameService.load(name3Uuid);\r
+ name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
\r
- service.deleteSynonym(synonym1, null, true, true);\r
+ service.saveOrUpdate(synonym1);\r
\r
- this.commitAndStartNewTransaction(tableNames);\r
+ int nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
+ Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);\r
+ SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();\r
+\r
+ service.deleteSynonym(synonym1, config);\r
\r
+ this.commitAndStartNewTransaction(tableNames);\r
+ //synonym is deleted, but the name can not be deleted because of a name relationship\r
nSynonyms = service.count(Synonym.class);\r
Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);\r
nNames = nameService.count(TaxonNameBase.class);\r
Assert.assertEquals("There should be 4 names left in the database (name is related to synonymName2)", 4, nNames);\r
- int nRelations = service.countAllRelationships();\r
+ nRelations = service.countAllRelationships();\r
//may change with better implementation of countAllRelationships (see #2653)\r
- Assert.assertEquals("There should be 0 taxon relationships left in the database", 0, nRelations);\r
nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);\r
- \r
- \r
+\r
+\r
//clean up database\r
- name2 = (TaxonNameBase)nameService.load(uuidSynonymName2);\r
+ name2 = nameService.load(uuidSynonymName2);\r
NameRelationship rel = CdmBase.deproxy(name2.getNameRelations().iterator().next(), NameRelationship.class);\r
name2.removeNameRelationship(rel);\r
nameService.save(name2);\r
this.endTransaction();\r
\r
}\r
+ @Test\r
+ @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameDeleteAllNameRelations(){\r
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
+ "SynonymRelationship","SynonymRelationship_AUD",\r
+ "HomotypicalGroup","HomotypicalGroup_AUD"};\r
+\r
+ int nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
+ int nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
+\r
+ UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");\r
+ UUID uuidTaxon2=UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");\r
+ UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
+ UUID uuidSynonym2=UUID.fromString("f8d86dc9-5f18-4877-be46-fbb9412465e4");\r
+ UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");\r
+\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
+ TaxonNameBase name2 = nameService.load(uuidSynonymName2);\r
+ UUID name3Uuid = synonym1.getName().getUuid();\r
+ TaxonNameBase name3 = nameService.load(name3Uuid);\r
+ name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
+\r
+ service.saveOrUpdate(synonym1);\r
+\r
+ int nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
+ Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);\r
+ SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();\r
+ NameDeletionConfigurator nameDeletionConfig = new NameDeletionConfigurator();\r
+ nameDeletionConfig.setRemoveAllNameRelationships(true);\r
+ config.setNameDeletionConfig(nameDeletionConfig);\r
+\r
+ service.deleteSynonym(synonym1, config);\r
+\r
+ this.commitAndStartNewTransaction(tableNames);\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 3 names left in the database ", 3, nNames);\r
+ nRelations = service.countAllRelationships();\r
+ //may change with better implementation of countAllRelationships (see #2653)\r
+ nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
+ Assert.assertEquals("There should be no name relationship left in the database", 0, nRelations);\r
+ }\r
+\r
+ @Test\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameIgnoreIsBasionym(){\r
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",\r
+ "SynonymRelationship","SynonymRelationship_AUD",\r
+ "HomotypicalGroup","HomotypicalGroup_AUD"};\r
+\r
+ int nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
+ int nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
+\r
+ UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");\r
+ UUID uuidTaxon2=UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");\r
+ UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
+ UUID uuidSynonym2=UUID.fromString("f8d86dc9-5f18-4877-be46-fbb9412465e4");\r
+ UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");\r
+\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
+ TaxonNameBase name2 = nameService.load(uuidSynonymName2);\r
+ UUID name3Uuid = synonym1.getName().getUuid();\r
+ TaxonNameBase name3 = nameService.load(name3Uuid);\r
+ name3.addRelationshipFromName(name2, NameRelationshipType.BASIONYM(), null);\r
+\r
+ service.saveOrUpdate(synonym1);\r
+\r
+ int nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
+ Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);\r
+ SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();\r
+ NameDeletionConfigurator nameDeletionConfig = new NameDeletionConfigurator();\r
+ nameDeletionConfig.setIgnoreIsBasionymFor(true);\r
+ config.setNameDeletionConfig(nameDeletionConfig);\r
+\r
+ DeleteResult result =service.deleteSynonym(synonym1, config);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ \r
+ \r
+ logger.debug(result);\r
+ this.commitAndStartNewTransaction(tableNames);\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 3 names left in the database ", 3, nNames);\r
+ nRelations = service.countAllRelationships();\r
+ //may change with better implementation of countAllRelationships (see #2653)\r
+ nRelations = nameService.getAllRelationships(1000, 0).size();\r
+ logger.info("number of name relations: " + nRelations);\r
+ Assert.assertEquals("There should be no name relationship left in the database", 0, nRelations);\r
+ }\r
+\r
\r
@Test\r
@DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")\r
int nNames = nameService.count(TaxonNameBase.class);\r
Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
int nRelations = service.countAllRelationships();\r
+\r
+\r
//may change with better implementation of countAllRelationships (see #2653)\r
- Assert.assertEquals("There should be 2 relationship in the database (the 2 synonym relationship) but no name relationship", 2, nRelations);\r
+\r
+ logger.debug("");\r
+ Assert.assertEquals("There should be 2 relationships in the database (the 2 synonym relationship) but no name relationship", 2, nRelations);\r
\r
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");\r
\r
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
- TaxonNameBase name2 = (TaxonNameBase)nameService.load(uuidSynonymName2);\r
+ TaxonNameBase name2 = nameService.load(uuidSynonymName2);\r
synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
\r
- service.deleteSynonym(synonym1, null, true, true);\r
+ service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
\r
this.rollback();\r
// printDataSet(System.out, tableNames);\r
Assert.assertEquals("There should be 4 names in the database", 4, nNames);\r
int nRelations = service.countAllRelationships();\r
//may change with better implementation of countAllRelationships (see #2653)\r
- Assert.assertEquals("There should be 2 relationship in the database (the 2 synonym relationship) but no name relationship", 2, nRelations);\r
+ Assert.assertEquals("There should be 2 relationship in the database (the 2 synonym relationships) but no name relationship", 2, nRelations);\r
\r
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");\r
\r
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
- TaxonNameBase name2 = (TaxonNameBase)nameService.load(uuidSynonymName2);\r
+ TaxonNameBase name2 = nameService.load(uuidSynonymName2);\r
synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
\r
service.saveOrUpdate(synonym1);\r
this.setComplete();\r
this.endTransaction();\r
\r
- printDataSet(System.out, tableNames);\r
+// printDataSet(System.out, tableNames);\r
\r
//out of wrapping transaction\r
- service.deleteSynonym(synonym1, null, true, true);\r
+ service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
\r
this.startNewTransaction();\r
\r
nRelations = service.countAllRelationships();\r
Assert.assertEquals("There should be no taxon or synonym relationship in the database", 0, nRelations);\r
nRelations = nameService.getAllRelationships(1000,0).size();\r
- Assert.assertEquals("There should be 1 name relationship in the database", 1, nRelations);\r
+ Assert.assertEquals("There should be one name relationship in the database", 1, nRelations);\r
\r
}\r
\r
@Test\r
@DataSet("TaxonServiceImplTest.testInferredSynonyms.xml")\r
- \r
public void testCreateInferredSynonymy(){\r
\r
- UUID classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");\r
+ UUID classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");\r
Classification tree = classificationService.find(classificationUuid);\r
UUID taxonUuid = UUID.fromString("bc09aca6-06fd-4905-b1e7-cbf7cc65d783");\r
- TaxonBase taxonBase = service.find(taxonUuid);\r
- List <TaxonBase> synonyms = service.list(Synonym.class, null, null, null, null);\r
+ TaxonBase<?> taxonBase = service.find(taxonUuid);\r
+ List <Synonym> synonyms = service.list(Synonym.class, null, null, null, null);\r
assertEquals("Number of synonyms should be 2",2,synonyms.size());\r
Taxon taxon = (Taxon)taxonBase;\r
+\r
//synonyms = taxonDao.getAllSynonyms(null, null);\r
//assertEquals("Number of synonyms should be 2",2,synonyms.size());\r
List<Synonym> inferredSynonyms = service.createInferredSynonyms(taxon, tree, SynonymRelationshipType.INFERRED_EPITHET_OF(), true);\r
assertNotNull("there should be a new synonym ", inferredSynonyms);\r
- System.err.println(inferredSynonyms.size());\r
- assertEquals ("the name of inferred epithet should be SynGenus lachesis", inferredSynonyms.get(0).getTitleCache(), "SynGenus lachesis sec. ");\r
+ assertEquals ("the name of inferred epithet should be SynGenus lachesis", "SynGenus lachesis sec. Sp. Pl.", inferredSynonyms.get(0).getTitleCache());\r
+\r
inferredSynonyms = service.createInferredSynonyms(taxon, tree, SynonymRelationshipType.INFERRED_GENUS_OF(), true);\r
assertNotNull("there should be a new synonym ", inferredSynonyms);\r
- System.err.println(inferredSynonyms.get(0).getTitleCache());\r
- assertEquals ("the name of inferred epithet should be SynGenus lachesis", inferredSynonyms.get(0).getTitleCache(), "Acherontia ciprosus sec. ");\r
+ assertEquals ("the name of inferred epithet should be SynGenus lachesis", "Acherontia ciprosus sec. Sp. Pl.", inferredSynonyms.get(0).getTitleCache());\r
+\r
inferredSynonyms = service.createInferredSynonyms(taxon, tree, SynonymRelationshipType.POTENTIAL_COMBINATION_OF(), true);\r
assertNotNull("there should be a new synonym ", inferredSynonyms);\r
- assertEquals ("the name of inferred epithet should be SynGenus lachesis", inferredSynonyms.get(0).getTitleCache(), "SynGenus ciprosus sec. ");\r
+ assertEquals ("the name of inferred epithet should be SynGenus lachesis", "SynGenus ciprosus sec. Sp. Pl.", inferredSynonyms.get(0).getTitleCache());\r
//assertTrue("set of synonyms should contain an inferred Synonym ", synonyms.contains(arg0))\r
}\r
\r
- @Test\r
- @DataSet("TaxonServiceImplTest.testDeleteTaxonConfig.xml")\r
- @Ignore //not fully working yet\r
- public final void testDeleteTaxonConfig(){\r
- final String[]tableNames = {\r
- "Classification", "Classification_AUD",\r
- "TaxonBase","TaxonBase_AUD",\r
- "TaxonNode","TaxonNode_AUD",\r
- "TaxonNameBase","TaxonNameBase_AUD",\r
- "SynonymRelationship","SynonymRelationship_AUD",\r
- "TaxonRelationship", "TaxonRelationship_AUD",\r
- "TaxonDescription", "TaxonDescription_AUD",\r
- "HomotypicalGroup","HomotypicalGroup_AUD",\r
- "PolytomousKey","PolytomousKey_AUD",\r
- "PolytomousKeyNode","PolytomousKeyNode_AUD",\r
- "Media","Media_AUD",\r
- "WorkingSet","WorkingSet_AUD",\r
- "DescriptionElementBase","DescriptionElementBase_AUD"};\r
-\r
- UUID uuidParent=UUID.fromString("b5271d4f-e203-4577-941f-00d76fa9f4ca");\r
- UUID uuidChild1=UUID.fromString("326167f9-0b97-4e7d-b1bf-4ca47b82e21e");\r
- UUID uuidSameAs=UUID.fromString("c2bb0f01-f2dd-43fb-ba12-2a85727ccb8d");\r
-\r
- int nTaxa = service.count(Taxon.class);\r
- Assert.assertEquals("There should be 3 taxa in the database", 3, nTaxa);\r
- Taxon parent = (Taxon)service.find(uuidParent);\r
- Assert.assertNotNull("Parent taxon should exist", parent);\r
- Taxon child1 = (Taxon)service.find(uuidChild1);\r
- Assert.assertNotNull("Child taxon should exist", child1);\r
-\r
-\r
- try {\r
-// commitAndStartNewTransaction(tableNames);\r
- service.deleteTaxon(child1, new TaxonDeletionConfigurator());\r
- Assert.fail("Delete should throw an error as long as name is used in classification.");\r
- } catch (ReferencedObjectUndeletableException e) {\r
- if (e.getMessage().contains("Taxon can't be deleted as it is used in a classification node")){\r
- //ok\r
- commitAndStartNewTransaction(tableNames);\r
- }else{\r
- Assert.fail("Unexpected error occurred when trying to delete taxon: " + e.getMessage());\r
- }\r
- }\r
-\r
- nTaxa = service.count(Taxon.class);\r
- Assert.assertEquals("There should be 3 taxa in the database", 3, nTaxa);\r
- child1 = (Taxon)service.find(uuidChild1);\r
- Assert.assertNotNull("Child taxon should exist", child1);\r
- Assert.assertEquals("Child should belong to 1 node", 1, child1.getTaxonNodes().size());\r
-\r
- TaxonNode node = child1.getTaxonNodes().iterator().next();\r
- node.getParent().deleteChildNode(node);\r
- service.save(node.getTaxon());\r
- commitAndStartNewTransaction(tableNames);\r
-\r
- child1 = (Taxon)service.find(uuidChild1);\r
- try {\r
- service.deleteTaxon(child1, new TaxonDeletionConfigurator());\r
- } catch (ReferencedObjectUndeletableException e) {\r
- Assert.fail("Delete should not throw an exception anymore");\r
- }\r
+ @Test\r
+ @DataSet("BlankDataSet.xml")\r
+ public final void testTaxonDeletionConfig(){\r
+ final String[]tableNames = {\r
+ "Classification", "Classification_AUD",\r
+ "TaxonBase","TaxonBase_AUD",\r
+ "TaxonNode","TaxonNode_AUD",\r
+ "TaxonNameBase","TaxonNameBase_AUD",\r
+ "SynonymRelationship","SynonymRelationship_AUD",\r
+ "TaxonRelationship", "TaxonRelationship_AUD",\r
+ "TaxonDescription", "TaxonDescription_AUD",\r
+ "HomotypicalGroup","HomotypicalGroup_AUD",\r
+ "PolytomousKey","PolytomousKey_AUD",\r
+ "PolytomousKeyNode","PolytomousKeyNode_AUD",\r
+ "Media","Media_AUD",\r
+ "WorkingSet","WorkingSet_AUD",\r
+ "DescriptionElementBase","DescriptionElementBase_AUD",\r
+ "DeterminationEvent","DeterminationEvent_AUD",\r
+ "SpecimenOrObservationBase","SpecimenOrObservationBase_AUD"};\r
+\r
+ UUID uuidParent=UUID.fromString("b5271d4f-e203-4577-941f-00d76fa9f4ca");\r
+ UUID uuidChild1=UUID.fromString("326167f9-0b97-4e7d-b1bf-4ca47b82e21e");\r
+ UUID uuidSameAs=UUID.fromString("c2bb0f01-f2dd-43fb-ba12-2a85727ccb8d");\r
+ commitAndStartNewTransaction(tableNames);\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ service.save(testTaxon);\r
+ commitAndStartNewTransaction(tableNames);\r
+ int nTaxa = service.count(Taxon.class);\r
+ \r
+ Assert.assertEquals("There should be 4 taxa in the database", 4, nTaxa);\r
+ Taxon parent = (Taxon)service.find(TaxonGenerator.GENUS_UUID);\r
+ Assert.assertNotNull("Parent taxon should exist", parent);\r
+ Taxon child1 = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+ Assert.assertNotNull("Child taxon should exist", child1);\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
+ config.setDeleteTaxonNodes(false);\r
+ config.setDeleteMisappliedNamesAndInvalidDesignations(false);\r
+ //try {\r
+ //commitAndStartNewTransaction(tableNames);\r
+\r
+ DeleteResult result = service.deleteTaxon(child1, config, null);\r
+ if (result.isOk()){ \r
+ Assert.fail("Delete should throw an error as long as name is used in classification.");\r
+ } \r
+\r
+ nTaxa = service.count(Taxon.class);\r
+ Assert.assertEquals("There should be 4 taxa in the database", 4, nTaxa);\r
+ child1 = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+ Assert.assertNotNull("Child taxon should exist", child1);\r
+ Assert.assertEquals("Child should belong to 1 node", 1, child1.getTaxonNodes().size());\r
+\r
+ TaxonNode node = child1.getTaxonNodes().iterator().next();\r
+ child1.addSource(IdentifiableSource.NewInstance(OriginalSourceType.Import));\r
+ \r
+ SpecimenOrObservationBase<IIdentifiableEntityCacheStrategy> identifiedUnit = DerivedUnit.NewInstance(SpecimenOrObservationType.DerivedUnit);\r
+ DeterminationEvent determinationEvent = DeterminationEvent.NewInstance(child1, identifiedUnit);\r
+ //UUID eventUUID = eventService.save(determinationEvent);\r
+ UUID identifiedUnitUUID = occurenceService.save(identifiedUnit);\r
+ \r
+ \r
+ TaxonNode parentNode = node.getParent();\r
+ parentNode =CdmBase.deproxy(parentNode, TaxonNode.class);\r
+ parentNode.deleteChildNode(node);\r
+ nodeService.save(parentNode);\r
+ //commitAndStartNewTransaction(tableNames);\r
+\r
+ // try {\r
+\r
+ result = service.deleteTaxon(child1, config, null);\r
+ if (result.isOk()){\r
+ Assert.fail("Delete should throw an exception because of the determination event");\r
+ }\r
+ \r
+ \r
+ \r
+ //determinationEvent = (DeterminationEvent)eventService.load(eventUUID);\r
+ commitAndStartNewTransaction(tableNames);\r
+ identifiedUnit = occurenceService.load(identifiedUnitUUID);\r
+ \r
+ occurenceService.delete(identifiedUnit);\r
+ \r
+ commitAndStartNewTransaction(tableNames);\r
+ child1 = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+\r
+ assertEquals(0, child1.getTaxonNodes().size());\r
+ // try {\r
+\r
+ result = service.deleteTaxon(child1, config, null);\r
+ \r
+ if (!result.isOk()){\r
+ Assert.fail("Delete should not throw an exception anymore");\r
+ }\r
+ \r
+ nTaxa = service.count(Taxon.class);\r
+ Assert.assertEquals("There should be 3 taxa in the database", 3, nTaxa);\r
+\r
+ config.setDeleteTaxonNodes(true);\r
+ Taxon child2 =(Taxon) service.find(TaxonGenerator.SPECIES2_UUID);\r
\r
+ // try {\r
+ result = service.deleteTaxon(child2, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail("Delete should not throw an exception");\r
+ }\r
+ \r
+ \r
+ //service.find(uuid);\r
\r
+ nTaxa = service.count(Taxon.class);\r
+ Assert.assertEquals("There should be 2 taxa in the database",2, nTaxa);\r
// nNames = nameService.count(TaxonNameBase.class);\r
// Assert.assertEquals("There should be 3 names left in the database", 3, nNames);\r
// int nRelations = service.countAllRelationships();\r
// Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);\r
- }\r
-\r
-\r
-// @Test\r
-// public final void testDeleteTaxonCreateData(){\r
-// final String[]tableNames = {"TaxonBase","TaxonBase_AUD",\r
-// "TaxonNode","TaxonNode_AUD",\r
-// "TaxonNameBase","TaxonNameBase_AUD",\r
-// "SynonymRelationship","SynonymRelationship_AUD",\r
-// "TaxonRelationship", "TaxonRelationship_AUD",\r
-// "TaxonDescription", "TaxonDescription_AUD",\r
-// "HomotypicalGroup","HomotypicalGroup_AUD",\r
-// "PolytomousKey","PolytomousKey_AUD",\r
-// "PolytomousKeyNode","PolytomousKeyNode_AUD",\r
-// "Media","Media_AUD",\r
-// "WorkingSet","WorkingSet_AUD",\r
-// "DescriptionElementBase","DescriptionElementBase_AUD",\r
-// "Classification","Classification_AUD"};\r
-//\r
-//\r
-// BotanicalName taxonName1 = BotanicalName.NewInstance(Rank.GENUS());\r
-// taxonName1.setTitleCache("parent",true);\r
-// BotanicalName taxonName2 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// taxonName2.setTitleCache("child1",true);\r
-// BotanicalName synonymName1 = BotanicalName.NewInstance(Rank.SPECIES());\r
-// synonymName1.setTitleCache("Synonym1",true);\r
-// BotanicalName sameAsName = BotanicalName.NewInstance(Rank.SPECIES());\r
-// sameAsName.setTitleCache("sameAs",true);\r
-//\r
-// Reference<?> sec = null;\r
-// Taxon parent = Taxon.NewInstance(taxonName1, sec);\r
-// Taxon child1 = Taxon.NewInstance(taxonName2, sec);\r
-// Synonym synonym1 = Synonym.NewInstance(synonymName1, sec);\r
-// Taxon sameAs = Taxon.NewInstance(sameAsName, sec);\r
-//\r
-// child1.addSynonym(synonym1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
-// Classification classification1 = Classification.NewInstance("classification1");\r
-// classification1.addParentChild(parent, child1, null, null);\r
-//\r
-//\r
-// child1.addTaxonRelation(sameAs, TaxonRelationshipType.CONGRUENT_TO(), null, null);\r
-//\r
-// service.save(child1);\r
-//\r
-// this.commitAndStartNewTransaction(tableNames);\r
-//\r
-// }\r
+ }\r
+\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testDeleteTaxon(){\r
+\r
+ //create a small classification\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon speciesTaxon = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+ Iterator<TaxonDescription> descriptionIterator = speciesTaxon.getDescriptions().iterator();\r
+ UUID descrUUID = null;\r
+ UUID descrElementUUID = null;\r
+ if (descriptionIterator.hasNext()){\r
+ TaxonDescription descr = descriptionIterator.next();\r
+ descrUUID = descr.getUuid();\r
+ descrElementUUID = descr.getElements().iterator().next().getUuid();\r
+ }\r
+ BotanicalName taxonName = (BotanicalName) nameService.find(TaxonGenerator.SPECIES1_NAME_UUID);\r
+ assertNotNull(taxonName);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
+ config.setDeleteNameIfPossible(false);\r
+ \r
+ \r
+\r
+ // try {\r
+ DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+\r
+ taxonName = (BotanicalName) nameService.find(TaxonGenerator.SPECIES1_NAME_UUID);\r
+ Taxon taxon = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+\r
+ //descriptionService.find(descrUUID);\r
+ assertNull(descriptionService.find(descrUUID));\r
+ assertNull(descriptionService.getDescriptionElementByUuid(descrElementUUID));\r
+ //assertNull(synName);\r
+ assertNotNull(taxonName);\r
+ assertNull(taxon);\r
+ config.setDeleteNameIfPossible(true);\r
+ Taxon newTaxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.SPECIES()), null);\r
+ service.save(newTaxon);\r
+ result = service.deleteTaxon(newTaxon, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ \r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="BlankDataSet.xml")\r
+ public final void testDeleteTaxonDeleteSynonymRelations(){\r
+ \r
+ final String[]tableNames = {\r
+ "Classification", "Classification_AUD",\r
+ "TaxonBase","TaxonBase_AUD",\r
+ "TaxonNode","TaxonNode_AUD",\r
+ "TaxonNameBase","TaxonNameBase_AUD"};\r
+ commitAndStartNewTransaction(tableNames);\r
+ //create a small classification\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon speciesTaxon = (Taxon)service.find(TaxonGenerator.SPECIES2_UUID);\r
+\r
+ SynonymRelationship synRel = speciesTaxon.getSynonymRelations().iterator().next();\r
+ UUID synonymRelationUuid = synRel.getUuid();\r
+ UUID synonymUuid = synRel.getSynonym().getUuid();\r
+ int i = service.getAllRelationships(1000, 0).size();\r
+ \r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
+ config.setDeleteSynonymsIfPossible(false);\r
+\r
+ \r
+ DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+\r
+ Taxon taxon = (Taxon)service.find(TaxonGenerator.SPECIES2_UUID);\r
+ assertNull("The deleted taxon should no longer exist", taxon);\r
+\r
+ assertNotNull("The synonym should still exist since DeleteSynonymsIfPossible was false", service.find(synonymUuid));\r
+\r
+ for(RelationshipBase rel : service.getAllRelationships(1000, 0)){\r
+ if(rel instanceof SynonymRelationship && rel.getUuid().equals(synonymRelationUuid)){\r
+ Assert.fail("The SynonymRelationship should no longer exist");\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testDeleteTaxonNameUsedInOtherContext(){\r
+\r
+ //create a small classification\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon speciesTaxon = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+\r
+ BotanicalName taxonName = (BotanicalName) nameService.find(TaxonGenerator.SPECIES1_NAME_UUID);\r
+ assertNotNull(taxonName);\r
+ BotanicalName fromName = BotanicalName.NewInstance(Rank.SPECIES());\r
+ taxonName.addRelationshipFromName(fromName, NameRelationshipType.VALIDATED_BY_NAME(), null);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
+ config.setDeleteNameIfPossible(true);\r
+ DeleteResult result = service.deleteTaxon(speciesTaxon, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+\r
+ taxonName = (BotanicalName) nameService.find(TaxonGenerator.SPECIES1_NAME_UUID);\r
+ Taxon taxon = (Taxon)service.find(TaxonGenerator.SPECIES1_UUID);\r
+ //because of the namerelationship the name cannot be deleted\r
+ assertNotNull(taxonName);\r
+ assertNull(taxon);\r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testDeleteTaxonNameUsedInTwoClassificationsDeleteAllNodes(){\r
+ commitAndStartNewTransaction(null);\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();\r
+ //create a small classification\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+\r
+ UUID uuid = service.save(testTaxon);\r
+ //BotanicalName name = nameService.find(uuid);\r
+ Set<TaxonNode> nodes = testTaxon.getTaxonNodes();\r
+ TaxonNode node = nodes.iterator().next();\r
+ List<TaxonNode> childNodes = node.getChildNodes();\r
+ TaxonNode childNode = childNodes.iterator().next();\r
+ UUID childUUID = childNode.getTaxon().getUuid();\r
+ Classification secondClassification = TaxonGenerator.getTestClassification("secondClassification");\r
+\r
+ secondClassification.addChildTaxon(testTaxon, null, null);\r
+ //delete the taxon in all classifications\r
+ //try {\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ if (!result.isOk()){\r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ Taxon childTaxon = (Taxon)service.find(childUUID);\r
+ assertNull(tax);\r
+ commitAndStartNewTransaction(null);\r
+\r
+\r
+\r
+\r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testDeleteTaxonNameUsedInTwoClassificationsDoNotDeleteAllNodes(){\r
+ // delete the taxon only in second classification, this should delete only the nodes, not the taxa\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+ Classification secondClassification = TaxonGenerator.getTestClassification("secondClassification");\r
+ Set<TaxonNode> nodes = testTaxon.getTaxonNodes();\r
+ TaxonNode node = nodes.iterator().next();\r
+ List<TaxonNode> childNodes = node.getChildNodes();\r
+ TaxonNode childNode = childNodes.iterator().next();\r
+ UUID childUUID = childNode.getTaxon().getUuid();\r
+ childNode = secondClassification.addChildTaxon(testTaxon, null, null);\r
+ UUID childNodeUUID = childNode.getUuid();\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.setDeleteInAllClassifications(false);\r
+ // try {\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, secondClassification);\r
+/* Assert.fail("The taxon should not be deletable because it is used in a second classification and the configuration is set to deleteInAllClassifications = false");\r
+ } catch (DataChangeNoRollbackException e) {\r
+ logger.debug(e.getMessage());\r
+ }\r
+ */ \r
+ \r
+ if (result.isOk()){\r
+ Assert.fail("The taxon should not be deletable because it is used in a second classification and the configuration is set to deleteInAllClassifications = false");\r
+ }\r
+\r
+ //commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNotNull(tax);\r
+ Taxon childTaxon = (Taxon)service.find(childUUID);\r
+ assertNotNull(tax);\r
+ node = nodeService.find(childNodeUUID);\r
+ assertNull(node);\r
+ }\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonNodeDeletionConfiguratorMoveToParent(){\r
+ //test childHandling MOVE_TO_PARENT:\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon topMost = Taxon.NewInstance(BotanicalName.NewInstance(Rank.FAMILY()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ Classification classification = node.getClassification();\r
+ classification.addParentChild(topMost, testTaxon, null, null);\r
+ UUID topMostUUID = service.save(topMost);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.getTaxonNodeConfig().setChildHandling(ChildHandling.MOVE_TO_PARENT);\r
+\r
+ \r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ if(!result.isOk()){ \r
+ Assert.fail();\r
+ }\r
+ \r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ tax = (Taxon)service.find(topMostUUID);\r
+ Set<TaxonNode> topMostNodes = tax.getTaxonNodes();\r
+ assertNotNull(topMostNodes);\r
+ assertEquals("there should be one taxon node", 1, topMostNodes.size());\r
+ nodes = topMostNodes.iterator();\r
+ TaxonNode topMostNode = nodes.next();\r
+ int size = topMostNode.getChildNodes().size();\r
+\r
+ assertEquals(2, size);\r
+ }\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonNodeDeletionConfiguratorDeleteChildren(){\r
+ //test childHandling DELETE:\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon topMost = Taxon.NewInstance(BotanicalName.NewInstance(Rank.FAMILY()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ UUID taxonNodeUUID = node.getUuid();\r
+ Classification classification = node.getClassification();\r
+ classification.addParentChild(topMost, testTaxon, null, null);\r
+ UUID topMostUUID = service.save(topMost);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.getTaxonNodeConfig().setChildHandling(ChildHandling.DELETE);\r
+\r
+ // try {\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ if(!result.isOk()){ \r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ tax = (Taxon)service.find(topMostUUID);\r
+ Set<TaxonNode> topMostNodes = tax.getTaxonNodes();\r
+ assertNotNull(topMostNodes);\r
+ assertEquals("there should be one taxon node", 1, topMostNodes.size());\r
+ nodes = topMostNodes.iterator();\r
+ TaxonNode topMostNode = nodes.next();\r
+ int size = topMostNode.getChildNodes().size();\r
+ node = nodeService.find(taxonNodeUUID);\r
+ assertNull(node);\r
+ assertEquals(0, size);\r
+ }\r
+\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonDeletionConfiguratorDeleteMarker(){\r
+ //test childHandling DELETE:\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon topMost = Taxon.NewInstance(BotanicalName.NewInstance(Rank.FAMILY()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ Classification classification = node.getClassification();\r
+ classification.addParentChild(topMost, testTaxon, null, null);\r
+ UUID topMostUUID = service.save(topMost);\r
+ Marker marker = Marker.NewInstance(testTaxon, true, MarkerType.IS_DOUBTFUL());\r
+ testTaxon.addMarker(marker);\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.getTaxonNodeConfig().setChildHandling(ChildHandling.DELETE);\r
+\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ \r
+ if(!result.isOk()){ \r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ tax = (Taxon)service.find(topMostUUID);\r
+ Set<TaxonNode> topMostNodes = tax.getTaxonNodes();\r
+ assertNotNull(topMostNodes);\r
+ assertEquals("there should be one taxon node", 1, topMostNodes.size());\r
+ nodes = topMostNodes.iterator();\r
+ TaxonNode topMostNode = nodes.next();\r
+ int size = topMostNode.getChildNodes().size();\r
+\r
+ assertEquals(0, size);\r
+ }\r
+\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonDeletionConfiguratorTaxonWithMisappliedName(){\r
+\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon misappliedName = Taxon.NewInstance(BotanicalName.NewInstance(Rank.GENUS()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ testTaxon.addMisappliedName(misappliedName, null, null);\r
+ UUID misappliedNameUUID = service.save(misappliedName);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.setDeleteMisappliedNamesAndInvalidDesignations(true);\r
+\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ if(!result.isOk()){ \r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ tax = (Taxon)service.find(misappliedNameUUID);\r
+ //TODO: is that correct or should it be deleted because there is no relation to anything\r
+ assertNull(tax);\r
+\r
+ }\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonDeletionConfiguratorTaxonWithMisappliedNameDoNotDelete(){\r
+\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon misappliedName = Taxon.NewInstance(BotanicalName.NewInstance(Rank.GENUS()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ testTaxon.addMisappliedName(misappliedName, null, null);\r
+ UUID misappliedNameUUID = service.save(misappliedName);\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+ config.setDeleteMisappliedNamesAndInvalidDesignations(false);\r
+\r
+ DeleteResult result = service.deleteTaxon(testTaxon, config, null);\r
+ if(!result.isOk()){ \r
+ Assert.fail();\r
+ }\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNull(tax);\r
+ tax = (Taxon)service.find(misappliedNameUUID);\r
+ //TODO: is that correct or should it be deleted because there is no relation to anything\r
+ assertNotNull(tax);\r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testTaxonDeletionConfiguratorTaxonMisappliedName(){\r
+\r
+ Taxon testTaxon = TaxonGenerator.getTestTaxon();\r
+ UUID uuid = service.save(testTaxon);\r
+\r
+ Taxon misappliedNameTaxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.GENUS()), null);\r
+\r
+ Iterator<TaxonNode> nodes = testTaxon.getTaxonNodes().iterator();\r
+ TaxonNode node =nodes.next();\r
+ testTaxon.addMisappliedName(misappliedNameTaxon, null, null);\r
+ UUID misappliedNameUUID = service.save(misappliedNameTaxon);\r
+ misappliedNameTaxon = (Taxon)service.find(misappliedNameUUID);\r
+ UUID misNameUUID = misappliedNameTaxon.getName().getUuid();\r
+\r
+ TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;\r
+\r
+\r
+ // try {\r
+ service.deleteTaxon(misappliedNameTaxon, config, null);\r
+ // } catch (DataChangeNoRollbackException e) {\r
+ // e.printStackTrace();\r
+\r
+ //}\r
+\r
+ commitAndStartNewTransaction(null);\r
+ Taxon tax = (Taxon)service.find(uuid);\r
+ assertNotNull(tax);\r
+ tax = (Taxon)service.find(misappliedNameUUID);\r
+ BotanicalName name = (BotanicalName) nameService.find(misNameUUID);\r
+\r
+ assertNull(tax);\r
+ assertNull(name);\r
+\r
+ }\r
+ \r
+ @Test\r
+ @DataSet(value="BlankDataSet.xml")\r
+ public final void testLlistIncludedTaxa(){\r
+ Reference<?> citation = null;\r
+ String microcitation = null;\r
+ \r
+ //Data\r
+ Classification cl1 = Classification.NewInstance("testClassification1");\r
+ Classification cl2 = Classification.NewInstance("testClassification2");\r
+ Classification cl3 = Classification.NewInstance("testClassification3");\r
+ \r
+ Taxon c1Genus = Taxon.NewInstance(null, null);c1Genus.setUuid(UUID.fromString("daa24f6f-7e38-4668-b385-10c789212e4e"));\r
+ Taxon c1Species = Taxon.NewInstance(null, null);c1Species.setUuid(UUID.fromString("1c1d0566-67d0-4806-bf23-ecf55f4b9118"));\r
+ Taxon c1SubSpecies1 = Taxon.NewInstance(null, null);c1SubSpecies1.setUuid(UUID.fromString("96ae2fad-76df-429f-b179-42e00838fea4"));\r
+ Taxon c1SubSpecies2 = Taxon.NewInstance(null, null);c1SubSpecies2.setUuid(UUID.fromString("5d3f6147-ca72-40e0-be8a-6c835a09a579"));\r
+ cl1.addParentChild(c1Genus, c1Species, null, null);\r
+ cl1.addParentChild(c1Species, c1SubSpecies1, null, null);\r
+ cl1.addParentChild(c1Species, c1SubSpecies2, null, null);\r
+ \r
+ Taxon c2Genus = Taxon.NewInstance(null, null);c2Genus.setUuid(UUID.fromString("ed0ec006-3ac8-4a12-ae13-fdf2a13dedbe"));\r
+ Taxon c2Species = Taxon.NewInstance(null, null);c2Species.setUuid(UUID.fromString("1027eb18-1c26-450e-a299-981b775ebc3c"));\r
+ Taxon c2SubSpecies1 = Taxon.NewInstance(null, null);c2SubSpecies1.setUuid(UUID.fromString("61f039c8-01f3-4f5d-8e16-1602139774e7"));\r
+ Taxon c2SubSpecies2 = Taxon.NewInstance(null, null);c2SubSpecies2.setUuid(UUID.fromString("2ed6b6f8-05f9-459a-a075-2bca57e3013e"));\r
+ cl2.addParentChild(c2Genus, c2Species, null, null);\r
+ cl2.addParentChild(c2Species, c2SubSpecies1, null, null);\r
+ cl2.addParentChild(c2Species, c2SubSpecies2, null, null);\r
+ \r
+ Taxon c3Genus = Taxon.NewInstance(null, null);c3Genus.setUuid(UUID.fromString("407dfc8d-7a4f-4370-ada4-76c1a8279d1f"));\r
+ Taxon c3Species = Taxon.NewInstance(null, null);c3Species.setUuid(UUID.fromString("b6d34fc7-4aa7-41e5-b633-86f474edbbd5"));\r
+ Taxon c3SubSpecies1 = Taxon.NewInstance(null, null);c3SubSpecies1.setUuid(UUID.fromString("01c07585-a422-40cd-9339-a74c56901d9f"));\r
+ Taxon c3SubSpecies2 = Taxon.NewInstance(null, null);c3SubSpecies2.setUuid(UUID.fromString("390c8e23-e05f-4f89-b417-50cf080f4c91"));\r
+ cl3.addParentChild(c3Genus, c3Species, null, null);\r
+ cl3.addParentChild(c3Species, c3SubSpecies1, null, null);\r
+ cl3.addParentChild(c3Species, c3SubSpecies2, null, null);\r
+ \r
+ classificationService.save(cl1);\r
+ classificationService.save(cl2);\r
+ classificationService.save(cl3);\r
+ \r
+ Taxon c4Genus = Taxon.NewInstance(null, null);c4Genus.setUuid(UUID.fromString("bfd6bbdd-0116-4ab2-a781-9316224aad78"));\r
+ Taxon c4Species = Taxon.NewInstance(null, null);c4Species.setUuid(UUID.fromString("9347a3d9-5ece-4d64-9035-e8aaf5d3ee02"));\r
+ Taxon c4SubSpecies = Taxon.NewInstance(null, null);c4SubSpecies.setUuid(UUID.fromString("777aabbe-4c3a-449c-ab99-a91f2fec9f07"));\r
+ \r
+ TaxonRelationship rel = c1Species.addTaxonRelation(c2Species, TaxonRelationshipType.CONGRUENT_TO(), citation, microcitation);\r
+ rel.setDoubtful(true);\r
+ c1Species.addTaxonRelation(c4Species, TaxonRelationshipType.INCLUDES(), citation, microcitation);\r
+ c2Species.addTaxonRelation(c1SubSpecies2, TaxonRelationshipType.INCLUDES(), citation, microcitation);\r
+ \r
+ service.saveOrUpdate(c1Species);\r
+ service.saveOrUpdate(c2Species);\r
+ \r
+ //Tests\r
+ //default starting at species 1\r
+ IncludedTaxaDTO dto = service.listIncludedTaxa(c1Species.getUuid(), new IncludedTaxonConfiguration(null, true, false));\r
+ Assert.assertNotNull("IncludedTaxaDTO", dto);\r
+ Assert.assertEquals("Result should contain 7 taxa: c1Species", 7, dto.getIncludedTaxa().size());\r
+ Assert.assertNotNull("date should not be null", dto.getDate());\r
+// Assert.assertTrue(dto.contains(taxonUuid));\r
+ //same without doubtful\r
+ dto = service.listIncludedTaxa(c1Species.getUuid(), new IncludedTaxonConfiguration(null, false, false));\r
+ Assert.assertEquals(4, dto.getIncludedTaxa().size());\r
+\r
+ //other example starting at Genus2\r
+ dto = service.listIncludedTaxa(c2Genus.getUuid(), new IncludedTaxonConfiguration(null, true, false));\r
+ Assert.assertEquals(8, dto.getIncludedTaxa().size());\r
+ //same without doubtful\r
+ dto = service.listIncludedTaxa(c2Genus.getUuid(), new IncludedTaxonConfiguration(null, false, false));\r
+ Assert.assertEquals(5, dto.getIncludedTaxa().size());\r
+ \r
+ //only congruent\r
+ dto = service.listIncludedTaxa(c1Species.getUuid(), new IncludedTaxonConfiguration(null, true, true));\r
+ Assert.assertEquals(2, dto.getIncludedTaxa().size());\r
+ //same without doubtful\r
+ dto = service.listIncludedTaxa(c1Species.getUuid(), new IncludedTaxonConfiguration(null, false, true));\r
+ Assert.assertEquals(1, dto.getIncludedTaxa().size());\r
+ \r
+ \r
+\r
+ \r
+ }\r
+\r
+ /* (non-Javadoc)\r
+ * @see eu.etaxonomy.cdm.test.integration.CdmIntegrationTest#createTestData()\r
+ */\r
+ @Override\r
+ public void createTestDataSet() throws FileNotFoundException {\r
+ // TODO Auto-generated method stub\r
+ \r
+ }\r
\r
\r
}\r
+\r
+\r
+\r
BGBM BDI Projects / cdmlib.git / blobdiff