*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
-*/ \r
+*/\r
\r
package eu.etaxonomy.cdm.api.service;\r
\r
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.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.junit.Assert;\r
import org.junit.Test;\r
+import org.unitils.dbunit.annotation.DataSet;\r
import org.unitils.spring.annotation.SpringBeanByType;\r
\r
-import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;\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.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.NameRelationshipType;\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.reference.INomenclaturalReference;\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.Synonym;\r
+import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
-import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;\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
-public class TaxonServiceImplTest extends CdmIntegrationTest {\r
- private static final Logger logger = Logger.getLogger(TaxonServiceImplTest.class);\r
- \r
- @SpringBeanByType\r
- private ITaxonService service;\r
- \r
- @SpringBeanByType\r
- private INameService nameService;\r
- \r
+\r
+\r
+public class TaxonServiceImplTest extends CdmTransactionalIntegrationTest {\r
+ private static final Logger logger = Logger.getLogger(TaxonServiceImplTest.class);\r
+\r
+ @SpringBeanByType\r
+ private ITaxonService service;\r
+\r
+ @SpringBeanByType\r
+ private INameService nameService;\r
+\r
+ @SpringBeanByType\r
+ private IReferenceService referenceService;\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
- * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#setDao(eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao)}.\r
- */\r
- @Test\r
- public final void testSetDao() {\r
- logger.warn("Not implemented yet");\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.\r
- */\r
- @Test\r
- public final void testGetTaxonByUuid() {\r
- Taxon expectedTaxon = Taxon.NewInstance(null, null);\r
- UUID uuid = service.save(expectedTaxon);\r
- TaxonBase actualTaxon = service.find(uuid);\r
- assertEquals(expectedTaxon, actualTaxon);\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#saveTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.\r
- */\r
- @Test\r
- public final void testSaveTaxon() {\r
- Taxon expectedTaxon = Taxon.NewInstance(null, null);\r
- UUID uuid = service.save(expectedTaxon);\r
- TaxonBase actualTaxon = service.find(uuid);\r
- assertEquals(expectedTaxon, actualTaxon);\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.\r
- */\r
- @Test\r
- public final void testRemoveTaxon() {\r
- Taxon taxon = Taxon.NewInstance(BotanicalName.NewInstance(null), null);\r
- UUID uuid = service.save(taxon);\r
- service.delete(taxon);\r
- TaxonBase actualTaxon = service.find(uuid);\r
- assertNull(actualTaxon);\r
- }\r
- \r
- /**\r
- * Test method for\r
- * {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#loadTreeBranchTo(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.name.Rank, java.util.List)}\r
- * .\r
- */\r
- @Test\r
- public final void loadTreeBranchTo() {\r
- logger.warn("Not yet implemented"); // TODO\r
- }\r
-\r
- /**\r
- * Test method for\r
- * {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#searchTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}\r
- * .\r
- */\r
- @Test\r
- public final void testSearchTaxaByName() {\r
- logger.warn("Not yet implemented"); // TODO\r
- }\r
-\r
- /**\r
- * Test method for\r
- * {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)}\r
- * .\r
- */\r
- @Test\r
- public final void testGetRootTaxa() {\r
- logger.warn("Not yet implemented"); // TODO\r
- }\r
- \r
- @Test\r
- public final void testPrintDataSet() {\r
- //printDataSet(System.out);\r
- }\r
- \r
- @Test\r
- public final void testMakeTaxonSynonym() {\r
- Rank rank = Rank.SPECIES();\r
- HomotypicalGroup group = HomotypicalGroup.NewInstance();\r
- Taxon tax1 = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test1", 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
- tax1.addHomotypicSynonym(synonym, null, null);\r
- UUID uuidTaxon = service.save(tax1);\r
- UUID uuidSyn = service.save(synonym);\r
- \r
- service.swapSynonymAndAcceptedTaxon(synonym, tax1);\r
- \r
- TaxonBase tax = service.find(uuidTaxon);\r
- TaxonBase syn = service.find(uuidSyn);\r
- HomotypicalGroup groupTest = tax.getHomotypicGroup();\r
- HomotypicalGroup groupTest2 = syn.getHomotypicGroup();\r
- assertEquals(groupTest, groupTest2);\r
- }\r
- \r
+\r
+\r
+ /**\r
+ * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.\r
+ */\r
+ @Test\r
+ public final void testGetTaxonByUuid() {\r
+ Taxon expectedTaxon = Taxon.NewInstance(null, null);\r
+ UUID uuid = service.save(expectedTaxon);\r
+ TaxonBase<?> actualTaxon = service.find(uuid);\r
+ assertEquals(expectedTaxon, actualTaxon);\r
+ }\r
+\r
+ /**\r
+ * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#saveTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.\r
+ */\r
+ @Test\r
+ public final void testSaveTaxon() {\r
+ Taxon expectedTaxon = Taxon.NewInstance(null, null);\r
+ UUID uuid = service.save(expectedTaxon);\r
+ TaxonBase<?> actualTaxon = service.find(uuid);\r
+ assertEquals(expectedTaxon, actualTaxon);\r
+ }\r
+\r
+ @Test\r
+ public final void testSaveOrUpdateTaxon() {\r
+ Taxon expectedTaxon = Taxon.NewInstance(null, null);\r
+ UUID uuid = service.save(expectedTaxon);\r
+ TaxonBase<?> actualTaxon = service.find(uuid);\r
+ assertEquals(expectedTaxon, actualTaxon);\r
+\r
+ actualTaxon.setName(BotanicalName.NewInstance(Rank.SPECIES()));\r
+ try{\r
+ service.saveOrUpdate(actualTaxon);\r
+ }catch(Exception e){\r
+ Assert.fail();\r
+ }\r
+ }\r
+ /**\r
+ * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.\r
+ */\r
+ @Test\r
+ public final void testRemoveTaxon() {\r
+ Taxon taxon = Taxon.NewInstance(BotanicalName.NewInstance(Rank.UNKNOWN_RANK()), null);\r
+ UUID uuid = service.save(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
+\r
+ @Test\r
+ public final void testMakeTaxonSynonym() {\r
+ Rank rank = Rank.SPECIES();\r
+ Taxon tax1 = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test1", 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
+ tax1.addHomotypicSynonym(synonym, null, null);\r
+ UUID uuidTaxon = service.save(tax1);\r
+ UUID uuidSyn = service.save(synonym);\r
+\r
+ service.swapSynonymAndAcceptedTaxon(synonym, tax1);\r
+\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
+ public final void testChangeSynonymToAcceptedTaxon(){\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 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(synonym.getHomotypicGroup());\r
+ //tax2.addHeterotypicSynonymName(synonym.getName());\r
+ taxWithSyn.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+ taxWithSyn.addSynonym(synonym2, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+\r
+ service.save(taxWithoutSyn);\r
+ UUID uuidSyn = service.save(synonym);\r
+ service.save(synonym2);\r
+ UUID uuidTaxWithSyn =service.save(taxWithSyn);\r
+\r
+ Taxon taxon = null;\r
+ try {\r
+ taxon = service.changeSynonymToAcceptedTaxon(synonym, taxWithSyn, true, true, null, null);\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
+ */\r
+ @Test\r
+ public final void testMoveSynonymToAnotherTaxon_OLD() {\r
+ SynonymRelationshipType heteroTypicSynonymRelationshipType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF();\r
+ Reference<?> reference = ReferenceFactory.newGeneric();\r
+ String referenceDetail = "test";\r
+\r
+ NonViralName<?> t1n = NonViralName.NewInstance(null);\r
+ Taxon t1 = Taxon.NewInstance(t1n, reference);\r
+ NonViralName<?> t2n = NonViralName.NewInstance(null);\r
+ Taxon t2 = Taxon.NewInstance(t2n, reference);\r
+ NonViralName<?> s1n = NonViralName.NewInstance(null);\r
+ Synonym s1 = Synonym.NewInstance(s1n, reference);\r
+ t1.addSynonym(s1, heteroTypicSynonymRelationshipType);\r
+\r
+ SynonymRelationship synonymRelation = t1.getSynonymRelations().iterator().next();\r
+\r
+ boolean keepReference = false;\r
+ boolean moveHomotypicGroup = false;\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(synonymRelation, t2, moveHomotypicGroup, heteroTypicSynonymRelationshipType, reference, referenceDetail, keepReference);\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ Assert.fail("Method call should not throw exception");\r
+ }\r
+\r
+ Assert.assertTrue("t1 should have no synonym relationships", t1.getSynonymRelations().isEmpty());\r
+\r
+ Set<SynonymRelationship> synonymRelations = t2.getSynonymRelations();\r
+ Assert.assertTrue("t2 should have exactly one synonym relationship", synonymRelations.size() == 1);\r
+\r
+ synonymRelation = synonymRelations.iterator().next();\r
+\r
+ Assert.assertEquals(t2, synonymRelation.getAcceptedTaxon());\r
+ Assert.assertEquals(heteroTypicSynonymRelationshipType, synonymRelation.getType());\r
+ Assert.assertEquals(reference, synonymRelation.getCitation());\r
+ Assert.assertEquals(referenceDetail, synonymRelation.getCitationMicroReference());\r
+ }\r
+\r
+ @Test\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testMoveSynonymToAnotherTaxon.xml")\r
+ public final void testMoveSynonymToAnotherTaxon() throws Exception {\r
+ final String[] tableNames = new String[]{"SynonymRelationship"};\r
+\r
+// printDataSet(System.err, new String[]{"AgentBase", "TaxonBase"});\r
+// printDataSet(System.err, new String[]{"TaxonNode"});\r
+\r
+ UUID uuidNewTaxon = UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");\r
+ UUID uuidOldTaxon = UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");\r
+ UUID uuidSyn1 = UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
+ UUID uuidSyn3 = UUID.fromString("3fba2b22-22ae-4291-af67-faab748a5232");\r
+ UUID uuidSyn4 = UUID.fromString("f9b589c7-50cf-4df2-a52e-1b85eb7e4805");\r
+ UUID uuidSyn5 = UUID.fromString("fcc0bcf8-8bac-43bd-9508-1e97821587dd");\r
+ UUID uuidSyn6 = UUID.fromString("0ccd4e7c-6fbd-4b7c-bd47-29e45b92f34b");\r
+ UUID uuidRef1 = UUID.fromString("336f9b38-698c-45d7-be7b-993ed3355bdc");\r
+ UUID uuidRef2 = UUID.fromString("c8f49d1a-69e1-48a3-98bb-45d61f3da3e7");\r
+\r
+\r
+ boolean moveHomotypicGroup = true;\r
+ SynonymRelationshipType newSynonymRelationshipType = null;\r
+ boolean keepReference = true;\r
+ Reference<?> newReference = null;\r
+ String newReferenceDetail = null;\r
+\r
+ Taxon newTaxon = (Taxon)service.load(uuidNewTaxon);\r
+ Synonym homotypicSynonym = (Synonym)service.load(uuidSyn1);\r
+ Assert.assertNotNull("Synonym should exist", homotypicSynonym);\r
+ Assert.assertEquals("Synonym should have 1 relation", 1, homotypicSynonym.getSynonymRelations().size());\r
+ SynonymRelationship rel = homotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon, rel.getAcceptedTaxon().getUuid());\r
+ Taxon oldTaxon = rel.getAcceptedTaxon();\r
+\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(rel, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);\r
+ Assert.fail("Homotypic synonym move to other taxon should throw an exception");\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ 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")){\r
+ //OK\r
+ commitAndStartNewTransaction(tableNames);\r
+ }else{\r
+ Assert.fail("Unexpected exception occurred: " + e.getMessage());\r
+ }\r
+ }\r
+ //Asserts\r
+ homotypicSynonym = (Synonym)service.load(uuidSyn1);\r
+ Assert.assertNotNull("Synonym should still exist", homotypicSynonym);\r
+ Assert.assertEquals("Synonym should still have 1 relation", 1, homotypicSynonym.getSynonymRelations().size());\r
+ rel = homotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", oldTaxon, rel.getAcceptedTaxon());\r
+\r
+ //test heterotypic synonym with other synonym in homotypic group\r
+ newTaxon = (Taxon)service.load(uuidNewTaxon);\r
+ Synonym heterotypicSynonym = (Synonym)service.load(uuidSyn3);\r
+ Assert.assertNotNull("Synonym should exist", heterotypicSynonym);\r
+ Assert.assertEquals("Synonym should have 1 relation", 1, heterotypicSynonym.getSynonymRelations().size());\r
+ rel = heterotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon, rel.getAcceptedTaxon().getUuid());\r
+ oldTaxon = rel.getAcceptedTaxon();\r
+ moveHomotypicGroup = false;\r
+\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(rel, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);\r
+ Assert.fail("Heterotypic synonym move to other taxon should throw an exception");\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ 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")){\r
+ //OK\r
+ commitAndStartNewTransaction(tableNames);\r
+ }else{\r
+ Assert.fail("Unexpected exception occurred: " + e.getMessage());\r
+ }\r
+ }\r
+ //Asserts\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn3);\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 still be the old taxon", oldTaxon, rel.getAcceptedTaxon());\r
+\r
+\r
+ //test heterotypic synonym with no other synonym in homotypic group\r
+ //+ keep reference\r
+\r
+// printDataSet(System.err, new String[]{"TaxonBase"});\r
+\r
+ newTaxon = (Taxon)service.load(uuidNewTaxon);\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn5);\r
+ Assert.assertNotNull("Synonym should exist", heterotypicSynonym);\r
+ Assert.assertEquals("Synonym should have 1 relation", 1, heterotypicSynonym.getSynonymRelations().size());\r
+ rel = heterotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon, rel.getAcceptedTaxon().getUuid());\r
+ oldTaxon = rel.getAcceptedTaxon();\r
+ moveHomotypicGroup = false;\r
+\r
+\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(rel, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ Assert.fail("Move of single heterotypic synonym should not throw exception: " + e.getMessage());\r
+ }\r
+ //Asserts\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
+\r
+// printDataSet(System.err, new String[]{"TaxonBase"});\r
+// System.exit(0);\r
+\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
+ Assert.assertEquals("Old detail should be kept", "rel5", rel.getCitationMicroReference());\r
+\r
+\r
+ //test heterotypic synonym with other synonym in homotypic group and moveHomotypicGroup="true"\r
+ //+ new detail\r
+ newTaxon = (Taxon)service.load(uuidNewTaxon);\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn3);\r
+ Reference<?> ref1 = referenceService.load(uuidRef1);\r
+ Assert.assertNotNull("Synonym should exist", heterotypicSynonym);\r
+ Assert.assertEquals("Synonym should have 1 relation", 1, heterotypicSynonym.getSynonymRelations().size());\r
+ rel = heterotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon, rel.getAcceptedTaxon().getUuid());\r
+ oldTaxon = rel.getAcceptedTaxon();\r
+ Assert.assertEquals("Detail should be ref1", ref1, rel.getCitation());\r
+ Assert.assertEquals("Detail should be 'rel3'", "rel3", rel.getCitationMicroReference());\r
+ TaxonNameBase<?,?> oldSynName3 = heterotypicSynonym.getName();\r
+\r
+ Synonym heterotypicSynonym4 = (Synonym)service.load(uuidSyn4);\r
+ Assert.assertNotNull("Synonym should exist", heterotypicSynonym4);\r
+ Assert.assertEquals("Synonym should have 1 relation", 1, heterotypicSynonym4.getSynonymRelations().size());\r
+ SynonymRelationship rel4 = heterotypicSynonym4.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of other synonym in group should be the old taxon", uuidOldTaxon, rel4.getAcceptedTaxon().getUuid());\r
+ Assert.assertSame("Homotypic group of both synonyms should be same", oldSynName3.getHomotypicalGroup() , heterotypicSynonym4.getName().getHomotypicalGroup() );\r
+\r
+ moveHomotypicGroup = true;\r
+ keepReference = false;\r
+\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(rel, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ Assert.fail("Move with 'moveHomotypicGroup = true' should not throw exception: " + e.getMessage());\r
+ }\r
+ //Asserts\r
+ commitAndStartNewTransaction(tableNames);\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn3);\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 relation should be new taxon now", newTaxon, rel.getAcceptedTaxon());\r
+ TaxonNameBase<?,?> synName3 = rel.getSynonym().getName();\r
+\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn4);\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 relation should be new taxon now", newTaxon, rel.getAcceptedTaxon());\r
+ Assert.assertNull("Old citation should be removed", rel.getCitation());\r
+ Assert.assertNull("Old detail should be removed", rel.getCitationMicroReference());\r
+ TaxonNameBase<?,?> synName4 = rel.getSynonym().getName();\r
+ Assert.assertEquals("Homotypic group of both synonyms should be equal", synName3.getHomotypicalGroup() , synName4.getHomotypicalGroup() );\r
+ Assert.assertSame("Homotypic group of both synonyms should be same", synName3.getHomotypicalGroup() , synName4.getHomotypicalGroup() );\r
+ Assert.assertEquals("Homotypic group of both synonyms should be equal to old homotypic group", oldSynName3.getHomotypicalGroup() , synName3.getHomotypicalGroup() );\r
+\r
+\r
+ //test single heterotypic synonym to homotypic synonym of new taxon\r
+ //+ new reference\r
+ newTaxon = (Taxon)service.load(uuidNewTaxon);\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
+ rel = heterotypicSynonym.getSynonymRelations().iterator().next();\r
+ Assert.assertEquals("Accepted taxon of single relation should be the old taxon", uuidOldTaxon, rel.getAcceptedTaxon().getUuid());\r
+ oldTaxon = rel.getAcceptedTaxon();\r
+ moveHomotypicGroup = false;\r
+ keepReference = false;\r
+ newReference = ref2;\r
+ newReferenceDetail = "newRefDetail";\r
+ newSynonymRelationshipType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF();\r
+\r
+ try {\r
+ service.moveSynonymToAnotherTaxon(rel, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);\r
+ } catch (HomotypicalGroupChangeException e) {\r
+ Assert.fail("Move of single heterotypic synonym should not throw exception: " + e.getMessage());\r
+ }\r
+ //Asserts\r
+ commitAndStartNewTransaction(tableNames);\r
+ heterotypicSynonym = (Synonym)service.load(uuidSyn6);\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("Relationship type should be 'homotypic synonym'", newSynonymRelationshipType, rel.getType());\r
+ Assert.assertEquals("Accepted taxon of single relation should be new taxon", newTaxon, rel.getAcceptedTaxon());\r
+ Assert.assertEquals("New citation should be ref2", ref2 ,rel.getCitation());\r
+ Assert.assertEquals("New detail should be kept", "newRefDetail", rel.getCitationMicroReference());\r
+\r
+ Assert.assertEquals("New taxon and new synonym should have equal homotypical group", rel.getSynonym().getHomotypicGroup(), rel.getAcceptedTaxon().getHomotypicGroup());\r
+ Assert.assertSame("New taxon and new synonym should have same homotypical group", rel.getSynonym().getHomotypicGroup(), rel.getAcceptedTaxon().getHomotypicGroup());\r
+ }\r
+\r
+\r
+\r
+ @Test\r
+ public final void testGetHeterotypicSynonymyGroups(){\r
+ Rank rank = Rank.SPECIES();\r
+ Reference<?> ref1 = ReferenceFactory.newGeneric();\r
+ //HomotypicalGroup group = HomotypicalGroup.NewInstance();\r
+ Taxon taxon1 = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test3", null, null, null, null, null, null, null), null);\r
+ Synonym synonym0 = Synonym.NewInstance(BotanicalName.NewInstance(rank, "Test2", null, null, null, null, null, null, null), null);\r
+ Synonym synonym1 = 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
+ synonym0.getName().setHomotypicalGroup(taxon1.getHomotypicGroup());\r
+ synonym2.getName().setHomotypicalGroup(synonym1.getHomotypicGroup());\r
+ //tax2.addHeterotypicSynonymName(synonym.getName());\r
+ taxon1.addSynonym(synonym1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+ taxon1.addSynonym(synonym2, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+\r
+ service.save(synonym1);\r
+ service.save(synonym2);\r
+ service.save(taxon1);\r
+\r
+ List<List<Synonym>> heteroSyns = service.getHeterotypicSynonymyGroups(taxon1, null);\r
+ Assert.assertEquals("There should be 1 heterotypic group", 1, heteroSyns.size());\r
+ List<Synonym> synList = heteroSyns.get(0);\r
+ Assert.assertEquals("There should be 2 heterotypic syns in group 1", 2, synList.size());\r
+\r
+ //test sec\r
+ synonym2.setSec(ref1);\r
+ heteroSyns = service.getHeterotypicSynonymyGroups(taxon1, null);\r
+ Assert.assertEquals("There should be 1 heterotypic group", 1, heteroSyns.size());\r
+ synList = heteroSyns.get(0);\r
+ Assert.assertEquals("getHeterotypicSynonymyGroups should be independent of sec reference", 2, synList.size());\r
+\r
+ }\r
+\r
+\r
+ @Test\r
+ public final void testGetHomotypicSynonymsByHomotypicGroup(){\r
+ Rank rank = Rank.SPECIES();\r
+ Reference<?> ref1 = ReferenceFactory.newGeneric();\r
+ //HomotypicalGroup group = HomotypicalGroup.NewInstance();\r
+ Taxon taxon1 = Taxon.NewInstance(BotanicalName.NewInstance(rank, "Test3", null, null, null, null, null, null, null), null);\r
+ Synonym synonym0 = Synonym.NewInstance(BotanicalName.NewInstance(rank, "Test2", null, null, null, null, null, null, null), null);\r
+ Synonym synonym1 = 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
+ synonym0.getName().setHomotypicalGroup(taxon1.getHomotypicGroup());\r
+ synonym2.getName().setHomotypicalGroup(synonym1.getHomotypicGroup());\r
+ //tax2.addHeterotypicSynonymName(synonym.getName());\r
+ taxon1.addSynonym(synonym0, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());\r
+ taxon1.addSynonym(synonym1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+ taxon1.addSynonym(synonym2, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
+\r
+ service.save(synonym1);\r
+ service.save(synonym2);\r
+ service.save(taxon1);\r
+\r
+ List<Synonym> homoSyns = service.getHomotypicSynonymsByHomotypicGroup(taxon1, null);\r
+ Assert.assertEquals("There should be 1 heterotypic group", 1, homoSyns.size());\r
+ Assert.assertSame("The homotypic synonym should be synonym0", synonym0, homoSyns.get(0));\r
+\r
+ //test sec\r
+ synonym0.setSec(ref1);\r
+ homoSyns = service.getHomotypicSynonymsByHomotypicGroup(taxon1, null);\r
+ Assert.assertEquals("getHeterotypicSynonymyGroups should be independent of sec reference", 1, homoSyns.size());\r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")\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
+\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 uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");\r
+\r
+\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\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 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
+ "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
+\r
+\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
+\r
+ commitAndStartNewTransaction(null);\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\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
+ 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
+ //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
+ 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
+\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
+\r
+ Taxon taxon1 = (Taxon)service.load(uuidTaxon1);\r
+ Taxon taxon2 = (Taxon)service.load(uuidTaxon2);\r
+ Synonym synonym1 = (Synonym)service.load(uuidSynonym1);\r
+ synonym1.addExtension(Extension.NewInstance());\r
+ service.saveOrUpdate(synonym1);\r
+ \r
+ service.deleteSynonym(synonym1, taxon1, new SynonymDeletionConfigurator());\r
+\r
+ this.commitAndStartNewTransaction(tableNames);\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should still be 2 synonyms left in the database (synonym is related to taxon2)", 2, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\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
+ @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
+ "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
+\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
+ 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 1 name relationship left in the database", 1, nRelations);\r
+\r
+\r
+ //clean up database\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.setComplete();\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
+ public final void testDeleteSynonymSynonymTaxonBooleanWithRollback(){\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
+\r
+ //may change with better implementation of countAllRelationships (see #2653)\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 = nameService.load(uuidSynonymName2);\r
+ synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
+\r
+ service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
+\r
+ this.rollback();\r
+// printDataSet(System.out, tableNames);\r
+ this.startNewTransaction();\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ Assert.assertEquals("There should still be 2 synonyms left in the database", 2, nSynonyms);\r
+ nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 4 names left in the database", 4, nNames);\r
+ 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
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")\r
+ public final void testDeleteSynonymSynonymTaxonBooleanWithoutTransaction(){\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
+ //may change with better implementation of countAllRelationships (see #2653)\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 = nameService.load(uuidSynonymName2);\r
+ synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);\r
+\r
+ service.saveOrUpdate(synonym1);\r
+\r
+ this.setComplete();\r
+ this.endTransaction();\r
+\r
+// printDataSet(System.out, tableNames);\r
+\r
+ //out of wrapping transaction\r
+ service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());\r
+\r
+ this.startNewTransaction();\r
+\r
+ nSynonyms = service.count(Synonym.class);\r
+ 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);\r
+ nNames = nameService.count(TaxonNameBase.class);\r
+ Assert.assertEquals("There should be 4 names left in the database", 4, nNames);\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 one name relationship in the database", 1, nRelations);\r
+\r
+ }\r
+\r
+ @Test\r
+ @DataSet("TaxonServiceImplTest.testInferredSynonyms.xml")\r
+ public void testCreateInferredSynonymy(){\r
+\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 <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
+ 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
+ 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", "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("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
+ @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