X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/c897d0ac43edf1511b5318e5146702030e880916..88b4ec597101c80b752c85316cf9c037e88c1fbc:/cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/TaxonServiceImplBusinessTest.java diff --git a/cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/TaxonServiceImplBusinessTest.java b/cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/TaxonServiceImplBusinessTest.java index 1396f934c0..74431a1214 100644 --- a/cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/TaxonServiceImplBusinessTest.java +++ b/cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/TaxonServiceImplBusinessTest.java @@ -1,25 +1,30 @@ // $Id$ /** * Copyright (C) 2007 EDIT -* European Distributed Institute of Taxonomy +* European Distributed Institute of Taxonomy * http://www.e-taxonomy.eu -* +* * The contents of this file are subject to the Mozilla Public License Version 1.1 * See LICENSE.TXT at the top of this package for the full license terms. */ package eu.etaxonomy.cdm.api.service; -import java.util.List; -import java.util.Set; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; -import junit.framework.Assert; +import java.io.FileNotFoundException; +import java.util.HashSet; +import java.util.List; +import java.util.UUID; +import org.junit.Assert; import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; +import org.unitils.spring.annotation.SpringBeanByType; -import eu.etaxonomy.cdm.model.common.DefaultTermInitializer; +import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException; import eu.etaxonomy.cdm.model.name.HomotypicalGroup; import eu.etaxonomy.cdm.model.name.NonViralName; import eu.etaxonomy.cdm.model.name.TaxonNameBase; @@ -29,58 +34,62 @@ import eu.etaxonomy.cdm.model.taxon.Synonym; import eu.etaxonomy.cdm.model.taxon.SynonymRelationship; import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType; import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonBase; import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType; +import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest; /** * This test checks of all the business logic methods do what they are expected to do. - * + * * @author n.hoffmann * @created Dec 16, 2010 * @version 1.0 */ -public class TaxonServiceImplBusinessTest { +public class TaxonServiceImplBusinessTest extends CdmIntegrationTest { private Synonym s1; + private Synonym s2; private Taxon t2; private Taxon t1; - private TaxonServiceImpl service; + @SpringBeanByType + private ITaxonService service; + + @SpringBeanByType + private INameService nameService; private String referenceDetail; - private Reference reference; + private Reference reference; private SynonymRelationshipType homoTypicSynonymRelationshipType; private SynonymRelationshipType heteroTypicSynonymRelationshipType; - private NonViralName s1n; - private NonViralName t2n; - private NonViralName t1n; - private NonViralName s2n; - - @BeforeClass - public static void setUpClass() throws Exception{ - new DefaultTermInitializer().initialize(); - } - + private NonViralName s1n; + private NonViralName t2n; + private NonViralName t1n; + private NonViralName s2n; + /** * @throws java.lang.Exception */ @Before public void setUp() throws Exception { - service = new TaxonServiceImpl(); + //service = new TaxonServiceImpl(); + //nameService = new NameServiceImpl(); t1n = NonViralName.NewInstance(null); t1 = Taxon.NewInstance(t1n, reference); - + t2n = NonViralName.NewInstance(null); t2 = Taxon.NewInstance(t2n, reference); - + s1n = NonViralName.NewInstance(null); s1 = Synonym.NewInstance(s1n, reference); - + s2n = NonViralName.NewInstance(null); - + s2 = Synonym.NewInstance(s2n, reference); + // referencing homoTypicSynonymRelationshipType = SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF(); heteroTypicSynonymRelationshipType = SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(); reference = ReferenceFactory.newGeneric(); - referenceDetail = "test"; + referenceDetail = "test"; } @@ -90,7 +99,7 @@ public class TaxonServiceImplBusinessTest { @Test public final void testSwapSynonymAndAcceptedTaxon() { t1.addSynonym(s1, homoTypicSynonymRelationshipType); - + service.swapSynonymAndAcceptedTaxon(s1, t1); } @@ -102,56 +111,75 @@ public class TaxonServiceImplBusinessTest { t1.addSynonym(s1, homoTypicSynonymRelationshipType); HomotypicalGroup oldGroup = s1.getName().getHomotypicalGroup(); - Assert.assertEquals("Homotypical group of new accepted taxon should contain exactly one name", 1, oldGroup.getTypifiedNames().size()); - Taxon taxon = service.changeSynonymToAcceptedTaxon(s1, t1,false, true, null, null); - - - Assert.assertTrue("Former accepted taxon should not have synonyms anymore", t1.getSynonyms().isEmpty()); + Assert.assertEquals("Homotypical group of new accepted taxon should contain exactly 2 names", 2, oldGroup.getTypifiedNames().size()); + boolean deleteSynonym = false; + boolean copyCitationInfo = true; + Taxon taxon = null; + try { + taxon = service.changeSynonymToAcceptedTaxon(s1, t1, deleteSynonym, copyCitationInfo, null, null); + Assert.fail("Change must fail for synonym and taxon in same homotypical group"); + } catch (HomotypicalGroupChangeException e) { + //OK + } + t1.addSynonym(s2, heteroTypicSynonymRelationshipType); + Assert.assertEquals("Homotypical group of old accepted taxon should still contain exactly 2 names", 2, oldGroup.getTypifiedNames().size()); + Assert.assertTrue("Old accepted taxon should now have 2 synonyms", t1.getSynonyms().size() == 2); + try { + taxon = service.changeSynonymToAcceptedTaxon(s2, t1, deleteSynonym, copyCitationInfo, null, null); + } catch (HomotypicalGroupChangeException e) { + Assert.fail("Change must not throw exception for heterotypic synonym change"); + } + + Assert.assertTrue("Former accepted taxon should still have 1 synonym", t1.getSynonyms().size() == 1); Assert.assertNotNull(taxon); - Assert.assertEquals(s1n, taxon.getName()); + Assert.assertEquals(s2n, taxon.getName()); HomotypicalGroup newGroup = taxon.getName().getHomotypicalGroup(); Assert.assertEquals("Homotypical group of new accepted taxon should contain exactly one name", 1, newGroup.getTypifiedNames().size()); } - + /** * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)}. */ @Test public final void testChangeSynonymWithMultipleSynonymsInHomotypicalGroupToAcceptedTaxon() { t1.addSynonym(s1, heteroTypicSynonymRelationshipType); - TaxonNameBase otherHeteroSynonymName = NonViralName.NewInstance(null); + TaxonNameBase otherHeteroSynonymName = NonViralName.NewInstance(null); t1.addHeterotypicSynonymName(otherHeteroSynonymName); - TaxonNameBase homotypicSynonymName = NonViralName.NewInstance(null); + TaxonNameBase homotypicSynonymName = NonViralName.NewInstance(null); Synonym homotypicSynonym = Synonym.NewInstance(homotypicSynonymName, t1.getSec()); t1.addHomotypicSynonym(homotypicSynonym, null, null); - + HomotypicalGroup group = s1.getHomotypicGroup(); - Reference citation1 = ReferenceFactory.newBook(); + Reference citation1 = ReferenceFactory.newBook(); String microReference1 = "p. 55"; SynonymRelationship s2rel = t1.addHeterotypicSynonymName(s2n, group, citation1, microReference1); Synonym s2 = s2rel.getSynonym(); HomotypicalGroup homoGroup2 = s1.getHomotypicGroup(); Assert.assertEquals("Homotypical group must be the same group as for the old synonym", group, homoGroup2); - - Taxon newTaxon = service.changeSynonymToAcceptedTaxon(s1, t1, false, true, null, null); - + + //run + Taxon newTaxon = null; + try { + newTaxon = service.changeSynonymToAcceptedTaxon(s1, t1, false, true, null, null); + } catch (HomotypicalGroupChangeException e1) { + Assert.fail("Invocation of change method should not throw an exception"); + } + Assert.assertEquals("Former accepted taxon should now have 2 synonyms left", 2, t1.getSynonyms().size()); Assert.assertEquals("Former accepted taxon should now have 1 heterotypic synonym group left", 1, t1.getHeterotypicSynonymyGroups().size()); - Assert.assertNotNull(newTaxon); Assert.assertEquals(s1n, newTaxon.getName()); Assert.assertEquals("New accepted taxon should have 1 synonym", 1, newTaxon.getSynonyms().size()); Assert.assertEquals("The new synonym must be the homotypic synonym of the old synonym", s2, newTaxon.getSynonyms().iterator().next()); - HomotypicalGroup homoGroup = newTaxon.getHomotypicGroup(); Assert.assertEquals("Homotypical group must be the same group as for the old synonym", group, homoGroup); - + List synonymsInNewTaxonsGroup = newTaxon.getSynonymsInGroup(homoGroup); String message = "New accepted taxon should have 1 synonym in its homotypic group: s2. The old synonym may still exist (or not) but not as a synonym of the new taxon"; Assert.assertEquals(message, 1, synonymsInNewTaxonsGroup.size()); Assert.assertTrue("The old synonym's homotypic 'partner' must be a synonym of the new accepted taxon, too.", synonymsInNewTaxonsGroup.contains(s2)); Assert.assertTrue("The old synonym must be in the new accepted taxons homotypic group as it has not been deleted ", newTaxon.getName().getHomotypicalGroup().equals(s2.getName().getHomotypicalGroup())); - + boolean iWasHere = false; for (Synonym syn : synonymsInNewTaxonsGroup){ if (syn.equals(s2) ){ @@ -161,17 +189,17 @@ public class TaxonServiceImplBusinessTest { } } Assert.assertTrue("Relationship to s2 must have been concidered in 'for'-loop", iWasHere); - + try { service.changeSynonymToAcceptedTaxon(homotypicSynonym, t1, false, true, null, null); Assert.fail("The method should throw an exception when invoked on taxa in the same homotypical group"); - } catch (IllegalArgumentException e) { + } catch (HomotypicalGroupChangeException e) { //OK } - + // Assert.assertNull("Synonym should not be used in a name anymore", s1.getName()); - - + + } /** @@ -180,77 +208,105 @@ public class TaxonServiceImplBusinessTest { @Test public final void testChangeSynonymToRelatedTaxon() { t1.addSynonym(s1, homoTypicSynonymRelationshipType); - service.changeSynonymToRelatedTaxon(s1, t2, TaxonRelationshipType.CONGRUENT_OR_EXCLUDES(), reference, referenceDetail); - } - - /** - * 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)}. - */ - @Test - public final void testMoveSynonymToAnotherTaxon() { - t1.addSynonym(s1, homoTypicSynonymRelationshipType); - - SynonymRelationship synonymRelation = t1.getSynonymRelations().iterator().next(); - - service.moveSynonymToAnotherTaxon(synonymRelation, t2, homoTypicSynonymRelationshipType, reference, referenceDetail); - - Assert.assertTrue("t1 should have no synonym relationships", t1.getSynonymRelations().isEmpty()); - - Set synonymRelations = t2.getSynonymRelations(); - Assert.assertTrue("t2 should have exactly one synonym relationship", synonymRelations.size() == 1); + HashSet newInstances = new HashSet(); + newInstances.add(s1); + newInstances.add(t1); + newInstances.add(t2); + service.save(newInstances); + TaxonNameBase synonymName = s1.getName(); + UUID synNameUUID = synonymName.getUuid(); + + Taxon newTaxon = service.changeSynonymToRelatedTaxon(s1, t2, TaxonRelationshipType.CONGRUENT_OR_EXCLUDES(), reference, referenceDetail); + //check removeTaxonBase() + //UUID s1UUID = service.update(s1); + UUID newTaxonUUID = service.save(newTaxon); + - synonymRelation = synonymRelations.iterator().next(); + s1 =(Synonym)service.find(s1.getUuid()); + newTaxon = (Taxon)service.find(newTaxonUUID); + assertNull(s1); + synonymName = nameService.find(synNameUUID); + assertFalse(synonymName.getTaxonBases().contains(s1)); + assertTrue(synonymName.getTaxonBases().contains(newTaxon)); - Assert.assertEquals(t2, synonymRelation.getAcceptedTaxon()); - Assert.assertEquals(homoTypicSynonymRelationshipType, synonymRelation.getType()); - Assert.assertEquals(reference, synonymRelation.getCitation()); - Assert.assertEquals(referenceDetail, synonymRelation.getCitationMicroReference()); } - +// +// Moved to TaxonServiceImplTest +// /** +// * 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)}. +// */ +// @Test +// public final void testMoveSynonymToAnotherTaxon() { +// t1.addSynonym(s1, homoTypicSynonymRelationshipType); +// +// SynonymRelationship synonymRelation = t1.getSynonymRelations().iterator().next(); +// +// boolean keepReference = false; +// boolean moveHomotypicGroup = false; +// try { +// service.moveSynonymToAnotherTaxon(synonymRelation, t2, moveHomotypicGroup, homoTypicSynonymRelationshipType, reference, referenceDetail, keepReference); +// } catch (HomotypicalGroupChangeException e) { +// // TODO Auto-generated catch block +// e.printStackTrace(); +// } +// +// Assert.assertTrue("t1 should have no synonym relationships", t1.getSynonymRelations().isEmpty()); +// +// Set synonymRelations = t2.getSynonymRelations(); +// Assert.assertTrue("t2 should have exactly one synonym relationship", synonymRelations.size() == 1); +// +// synonymRelation = synonymRelations.iterator().next(); +// +// Assert.assertEquals(t2, synonymRelation.getAcceptedTaxon()); +// Assert.assertEquals(homoTypicSynonymRelationshipType, synonymRelation.getType()); +// Assert.assertEquals(reference, synonymRelation.getCitation()); +// Assert.assertEquals(referenceDetail, synonymRelation.getCitationMicroReference()); +// } + @Test public void changeHomotypicalGroupOfSynonym(){ - + //s1 - Heterotypic t1.addSynonym(s1, heteroTypicSynonymRelationshipType); - + //s2 - heterotypic TaxonNameBase otherHeteroSynonymName = NonViralName.NewInstance(null); Synonym s2 = Synonym.NewInstance(otherHeteroSynonymName, t1.getSec()); t1.addSynonym(s2, heteroTypicSynonymRelationshipType, null, null); - TaxonNameBase otherHeteroSynonymNameB = NonViralName.NewInstance(null); + TaxonNameBase otherHeteroSynonymNameB = NonViralName.NewInstance(null); otherHeteroSynonymName.addBasionym(otherHeteroSynonymNameB); Synonym s2b = Synonym.NewInstance(otherHeteroSynonymNameB, t1.getSec()); t1.addSynonym(s2b, heteroTypicSynonymRelationshipType, null, null); - + //homotypic TaxonNameBase homotypicSynonymName = NonViralName.NewInstance(null); Synonym homotypicSynonym = Synonym.NewInstance(homotypicSynonymName, t1.getSec()); t1.addHomotypicSynonym(homotypicSynonym, null, null); t1.getName().addBasionym(homotypicSynonymName); - + //Preconditions test Assert.assertFalse("s2 must not be in s1 homotypic group", s2.getHomotypicGroup().equals(s1.getHomotypicGroup())); Assert.assertFalse("s2 must not be in t1 homotypic group", s2.getHomotypicGroup().equals(t1.getHomotypicGroup())); Assert.assertEquals("s2 must have exactly 1 synonym relationship", 1, s2.getSynonymRelations().size()); Assert.assertEquals("s2 must have heterotypic relationship", heteroTypicSynonymRelationshipType, s2.getSynonymRelations().iterator().next().getType()); Assert.assertEquals("s2 must have exactly 1 basionym relationships", 1, s2.getName().getBasionyms().size()); - + //do it service.changeHomotypicalGroupOfSynonym(s2, s1.getHomotypicGroup(), t1, false, true); - + //postconditions Assert.assertEquals("s2 must be in s1 homotypic group", s2.getHomotypicGroup(), s1.getHomotypicGroup()); Assert.assertEquals("s2 must have exactly 1 synonym relationship", 1, s2.getSynonymRelations().size()); Assert.assertEquals("s2 must have heterotypic relationship", heteroTypicSynonymRelationshipType, s2.getSynonymRelations().iterator().next().getType()); Assert.assertEquals("s2 must have exactly 0 basionym relationships", 0, s2.getName().getBasionyms().size()); - + //Preconditions test Assert.assertEquals("'homotypicSynonym' must have exactly 1 basionym relationships", 1, homotypicSynonym.getName().getNameRelations().size()); Assert.assertEquals("'t1' must have exactly 1 basionym relationships", 1, t1.getName().getBasionyms().size()); Assert.assertFalse("s2 must not be in t1 homotypic group", s2.getHomotypicGroup().equals(t1.getHomotypicGroup())); - + //do it service.changeHomotypicalGroupOfSynonym(s2, homotypicSynonym.getHomotypicGroup(), null, false, true); @@ -265,8 +321,8 @@ public class TaxonServiceImplBusinessTest { Assert.assertEquals("'t1' must have exactly 2 homotypic synonyms", 2, t1.getHomotypicSynonymsByHomotypicRelationship().size()); Assert.assertEquals("'t1' must have exactly 2 names in homotypic group", 2, t1.getHomotypicSynonymsByHomotypicGroup().size()); Assert.assertEquals("'t1' homotypic group must include 3 names (t1, s2, homotypicSynonym)", 3, t1.getHomotypicGroup().getTypifiedNames().size()); - - + + //do it service.changeHomotypicalGroupOfSynonym(s2, t2.getHomotypicGroup(), t2, true, false); @@ -281,7 +337,7 @@ public class TaxonServiceImplBusinessTest { Assert.assertEquals("'t1' must have exactly 1 homotypic synonyms", 1, t1.getHomotypicSynonymsByHomotypicRelationship().size()); Assert.assertEquals("'t1' must have exactly 1 names in homotypic group", 1, t1.getHomotypicSynonymsByHomotypicGroup().size()); Assert.assertEquals("'t1' homotypic group must include 2 names (t1, homotypicSynonym)", 2, t1.getHomotypicGroup().getTypifiedNames().size()); - + //do it service.changeHomotypicalGroupOfSynonym(s2, s1.getHomotypicGroup(), t1, false, false); @@ -296,4 +352,14 @@ public class TaxonServiceImplBusinessTest { } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.test.integration.CdmIntegrationTest#createTestData() + */ + @Override + public void createTestDataSet() throws FileNotFoundException { + // TODO Auto-generated method stub + + } + }