X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/9383e254a2d6c51066a557f9d27bae6ff24ee3e9..d2f1dbf2c82afa64d69d596895b5cfca90c11ce8:/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java diff --git a/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java b/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java index 5e5a459761..274e2800b4 100644 --- a/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java +++ b/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java @@ -13,7 +13,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -24,7 +23,6 @@ import java.util.List; import java.util.Set; import java.util.UUID; -import org.apache.log4j.Level; import org.hibernate.Hibernate; import org.hibernate.envers.query.AuditEntity; import org.hibernate.envers.query.criteria.AuditCriterion; @@ -37,19 +35,15 @@ import org.unitils.dbunit.annotation.DataSet; import org.unitils.dbunit.annotation.ExpectedDataSet; import org.unitils.spring.annotation.SpringBeanByType; -import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper; import eu.etaxonomy.cdm.model.common.IdentifiableEntity; import eu.etaxonomy.cdm.model.common.Marker; import eu.etaxonomy.cdm.model.common.MarkerType; import eu.etaxonomy.cdm.model.location.NamedArea; -import eu.etaxonomy.cdm.model.name.NonViralName; -import eu.etaxonomy.cdm.model.name.Rank; -import eu.etaxonomy.cdm.model.name.TaxonNameBase; +import eu.etaxonomy.cdm.model.name.TaxonName; import eu.etaxonomy.cdm.model.reference.Reference; import eu.etaxonomy.cdm.model.taxon.Classification; 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.SynonymType; import eu.etaxonomy.cdm.model.taxon.Taxon; import eu.etaxonomy.cdm.model.taxon.TaxonBase; import eu.etaxonomy.cdm.model.taxon.TaxonNode; @@ -63,8 +57,8 @@ import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao; import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao; import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao; import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao; +import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao; import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache; -import eu.etaxonomy.cdm.persistence.fetch.CdmFetch; import eu.etaxonomy.cdm.persistence.query.GroupByCount; import eu.etaxonomy.cdm.persistence.query.GroupByDate; import eu.etaxonomy.cdm.persistence.query.Grouping; @@ -78,13 +72,15 @@ import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy; /** * @author a.mueller * @author ben.clark - * */ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @SpringBeanByType private ITaxonDao taxonDao; + @SpringBeanByType + private ITaxonNodeDao taxonNodeDao; + @SpringBeanByType private IClassificationDao classificationDao; @@ -92,44 +88,53 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { private IReferenceDao referenceDao; @SpringBeanByType - IDefinedTermDao definedTermDao; - - private UUID uuid; - private UUID sphingidae; - private UUID acherontia; - private UUID mimas; - private UUID rethera; - private UUID retheraSecCdmtest; - private UUID atroposAgassiz; // a Synonym - private UUID atroposLeach; // a Synonym - private UUID acherontiaLachesis; + private IDefinedTermDao definedTermDao; + + private UUID uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); + private UUID sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9"); + private UUID acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa"); + private UUID rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); + private UUID retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); + private UUID atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1"); // a Synonym + private UUID atroposOken = UUID.fromString("6bfedf25-6dbc-4d5c-9d56-84f9052f3b2a"); // a Synonym + private UUID atroposLeach = UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07"); // a Synonym + private UUID acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06"); + private UUID aus = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); + + private UUID UUID_ACHERONTIA_NODE = UUID.fromString("56b10cf0-9522-407e-9f90-0c2dba263c94"); + private UUID UUID_CLASSIFICATION2 = UUID.fromString("a71467a6-74dc-4148-9530-484628a5ab0e"); private AuditEvent previousAuditEvent; private AuditEvent mostRecentAuditEvent; private UUID northernAmericaUuid; private UUID southernAmericaUuid; - private UUID antarcticaUuid; private UUID classificationUuid; + private boolean includeUnpublished = true; + private boolean NO_UNPUBLISHED = false; + + private static final boolean doTaxa = true; + private static final boolean noTaxa = false; + private static final boolean doSynonyms = true; + private static final boolean noSynonyms = false; + private static final boolean doMisapplied = true; + private static final boolean noMisapplied = false; + private static final boolean doCommonNames = true; + private static final boolean noCommonNames = false; + + + + @SuppressWarnings("unused") private static final String[] TABLE_NAMES = new String[] { - "HOMOTYPICALGROUP", "HOMOTYPICALGROUP_AUD", "REFERENCE", "REFERENCE_AUD", "SYNONYMRELATIONSHIP", "SYNONYMRELATIONSHIP_AUD", "TAXONBASE", "TAXONBASE_AUD" - , "TAXONNAMEBASE", "TAXONNAMEBASE_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" }; + "HOMOTYPICALGROUP", "HOMOTYPICALGROUP_AUD", "REFERENCE", "REFERENCE_AUD", "TAXONBASE", "TAXONBASE_AUD" + , "TAXONNAME", "TAXONNAME_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" }; @Before public void setUp() { - uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); - sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9"); - acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa"); - acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06"); - atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1"); - atroposLeach = UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07"); - rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); - retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); - mimas = UUID.fromString("900052b7-b69c-4e26-a8f0-01c215214c40"); previousAuditEvent = new AuditEvent(); previousAuditEvent.setRevisionNumber(1025); @@ -141,9 +146,9 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f"); southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea"); - antarcticaUuid = UUID.fromString("791b3aa0-54dd-4bed-9b68-56b4680aad0c"); classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9"); + includeUnpublished = true; } @After @@ -162,88 +167,33 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertNotNull("Instance of IReferenceDao expected",referenceDao); } - /** - * Test method for - * {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)} - * . - */ @Test @DataSet - public void testGetRootTaxa() { - Reference sec1 = referenceDao.findById(1); - assert sec1 != null : "sec1 must exist"; - Reference sec2 = referenceDao.findById(2); - assert sec2 != null : "sec2 must exist"; - - List rootTaxa = taxonDao.getRootTaxa(sec1); - assertNotNull("getRootTaxa should return a List", rootTaxa); - assertFalse("The list should not be empty", rootTaxa.isEmpty()); - assertEquals("There should be one root taxon", 1, rootTaxa.size()); - - rootTaxa = taxonDao.getRootTaxa(sec1, CdmFetch.FETCH_CHILDTAXA(), true, false); - assertNotNull("getRootTaxa should return a List", rootTaxa); - assertFalse("The list should not be empty", rootTaxa.isEmpty()); - assertEquals("There should be one root taxon", 1, rootTaxa.size()); - - rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec1, CdmFetch.FETCH_CHILDTAXA(), true, false, null); - assertNotNull("getRootTaxa should return a List", rootTaxa); - assertFalse("The list should not be empty", rootTaxa.isEmpty()); - assertEquals("There should be one root taxon", 1, rootTaxa.size()); - - rootTaxa = taxonDao.getRootTaxa(Rank.FAMILY(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null); - if (logger.isDebugEnabled()) { - logger.debug("Root taxa rank Family (" + rootTaxa.size() + "):"); - for (Taxon taxon : rootTaxa) { - logger.debug(taxon.getTitleCache()); - } - } - assertEquals("There should be one root taxon rank Family", 1, rootTaxa.size()); - rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null); - assertNotNull("getRootTaxa should return a List", rootTaxa); - assertFalse("The list should not be empty", rootTaxa.isEmpty()); - if (logger.isDebugEnabled()) { - logger.debug("Root taxa rank Genus (" + rootTaxa.size() + "):"); - for (Taxon taxon : rootTaxa) { - logger.debug(taxon.getTitleCache()); - } - } - assertEquals("There should be 22 root taxa rank Genus", 22, rootTaxa.size()); + public void testGetTaxaByName() { - rootTaxa = taxonDao.getRootTaxa(Rank.SPECIES(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null); - if (logger.isDebugEnabled()) { - logger.debug("Root taxa rank Species (" + rootTaxa.size() + "):"); - for (Taxon taxon : rootTaxa) { - logger.debug(taxon.getTitleCache()); - } - } - assertEquals("There should be 4 root taxa rank Species", 3, rootTaxa.size()); - } + includeUnpublished= true; + boolean accepted = true; - /** - * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}. - */ - @Test - @DataSet - public void testGetTaxaByName() { Reference sec = referenceDao.findById(1); assert sec != null : "sec must exist"; - List results = taxonDao.getTaxaByName("Aus", sec); + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName("Aus", includeUnpublished, sec); assertNotNull("getTaxaByName should return a List", results); //assertFalse("The list should not be empty", results.isEmpty()); - assertTrue(results.size() == 1); + assertEquals(1, results.size()); - results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, true, null, null); + results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null); assertNotNull("getTaxaByName should return a List", results); - int numberOfTaxaByName_A = 9; + int numberOfTaxaByName_A = 5; - logger.setLevel(Level.DEBUG); //FIXME ####################### + //logger.setLevel(Level.DEBUG); //FIXME ####################### if (logger.isDebugEnabled()) { for (int i = 0; i < results.size(); i++) { String nameCache = ""; - TaxonNameBase taxonNameBase= results.get(i).getName(); - nameCache = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class).getNameCache(); + TaxonName taxonName= results.get(i).getName(); + nameCache = taxonName.getNameCache(); logger.debug(results.get(i).getClass() + "(" + i +")" + ": Name Cache = " + nameCache + ", Title Cache = " + results.get(i).getTitleCache()); } @@ -251,6 +201,10 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertEquals(numberOfTaxaByName_A, results.size()); + includeUnpublished = false; + results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null); + assertEquals(numberOfTaxaByName_A, results.size()); // no unpublished yet + //System.err.println("Species group: " + Rank.SPECIESGROUP().getId() + "Species: " + Rank.SPECIES().getId() + "Section Botany: "+ Rank.SECTION_BOTANY()); @@ -261,11 +215,12 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { // assertEquals(results.get(4).getTitleCache(), "Abies alba Michx. sec. ???"); // assertEquals(results.get(5).getTitleCache(), "Abies alba Mill. sec. ???"); - results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, true, null, null); + includeUnpublished = true; + results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals(numberOfTaxaByName_A, results.size()); - results = taxonDao.getTaxaByName("Aus", MatchMode.EXACT, true, null, null); + results = taxonDao.getTaxaByName("Aus", MatchMode.EXACT, accepted, includeUnpublished, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals("Results list should contain one entity",1,results.size()); } @@ -276,45 +231,101 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testGetTaxaByNameWithMisappliedNames(){ Classification classification = classificationDao.load(classificationUuid); - + TaxonNode subtree = null; /* NOTE: - * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis), two contained in the classification used in this test, - * the other one is not contained in any classification. This latter case is the more general situation. + * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis), + * two contained in the classification used in this test, + * the other one is not contained in any classification. This later case is the more general situation. * Misapplied names should be found regardless of whether they are contained in a classification or not. */ //two accepted taxa starting with R in classification "TestBaum" - List results = taxonDao.getTaxaByName(true, false, false, "R*", classification, MatchMode.BEGINNING, null, null, null, null); + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "R*", classification, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 2 Taxa", 2, results.size()); //three taxa, 2 accepted and 1 misapplied name starting with R - results = taxonDao.getTaxaByName(true, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(doTaxa, noSynonyms, doMisapplied, noCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); - //one synonym is not in a synonymrelationship - results = taxonDao.getTaxaByName(true, true, true, "A*", null, MatchMode.BEGINNING, null, null, null, null); + //one synonym has no accepted taxon + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "A*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 11 Taxa",11, results.size()); //two accepted taxa in classification and 1 misapplied name with accepted name in classification - results = taxonDao.getTaxaByName(true, true, true, "R*", classification, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", classification, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); + //same with unpublished + includeUnpublished = false; + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", classification, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 3 Taxa", 3, results.size()); + includeUnpublished = true; + //same as above because all taxa, synonyms and misapplied names starting with R are in the classification - results = taxonDao.getTaxaByName(true, true, true, "R*", null, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); //find misapplied names with accepted taxon in the classification, the accepted taxa of two misapplied names are in the classification - results = taxonDao.getTaxaByName(false, false, true, "*", classification, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "*", classification, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 2 Taxa", 2, results.size()); //find misapplied names beginning with R - results = taxonDao.getTaxaByName(false, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 1 Taxa", 1, results.size()); //find all three misapplied names - results = taxonDao.getTaxaByName(false, false, true, "*", null, MatchMode.BEGINNING, null, null, null, null); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); } + /** + * Test for all not covered possibilities of searches + */ + @Test + @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") + public void testGetTaxaByNameVariants(){ + TaxonNode subtree = null; + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 2 Taxa",2, results.size()); + + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, doCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 1 Taxa", 1, results.size()); + + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, doMisapplied, doCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 1 Taxa", 1, results.size()); + + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, doCommonNames, false, "c*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 2 Taxa", 2, results.size()); + + results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 2 Taxa", 2, results.size()); + + Classification classification = classificationDao.load(classificationUuid); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", classification, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 1 Taxa", 1, results.size()); + + Set namedAreas = new HashSet<>(); + namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, subtree, MatchMode.BEGINNING, + namedAreas, includeUnpublished, null, null, null, null); + Assert.assertEquals("There should be 1 Taxa", 1, results.size()); + } /** * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}. @@ -322,37 +333,40 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxaByNameForEditor() { + TaxonNode subtree = null; Reference sec = referenceDao.findById(1); assert sec != null : "sec must exist"; - List> results = taxonDao.getTaxaByNameForEditor(true, true, false,false,"Mand", null, MatchMode.BEGINNING, null); + @SuppressWarnings("rawtypes") + List> results = taxonDao.getTaxaByNameForEditor( + doTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "Acher", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); - //assertFalse("The list should not be empty", results.isEmpty()); - assertTrue(results.size() == 5); + assertFalse("The list should not be empty", results.isEmpty()); + assertEquals(4, results.size()); - results = taxonDao.getTaxaByNameForEditor(true, true, false, false,"A",null, MatchMode.BEGINNING, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "A",null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); - assertEquals(results.size(), 12); + assertEquals(7, results.size()); - results = taxonDao.getTaxaByNameForEditor(true, false,false, false,"A", null,MatchMode.BEGINNING, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); - assertTrue(results.size() == 9); + assertEquals(5, results.size()); assertEquals(results.get(0).getType(), Taxon.class); - results = taxonDao.getTaxaByNameForEditor(false, true,false,false, "A", null,MatchMode.BEGINNING, null); + results = taxonDao.getTaxaByNameForEditor(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); - assertTrue(results.size() == 3); + assertEquals(2, results.size()); assertEquals(results.get(0).getType(), Synonym.class); - results = taxonDao.getTaxaByNameForEditor(true, true,false,false,"Aus", null,MatchMode.EXACT, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "Aus", null, subtree, MatchMode.EXACT, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals("Results list should contain one entity",1,results.size()); - results = taxonDao.getTaxaByNameForEditor(true, true,true,false,"A", null,MatchMode.BEGINNING, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); - assertEquals("Results list should contain one entity",15,results.size()); + assertEquals("Results list should contain one entity", 8, results.size()); //TODO: test the search for misapplied names @@ -366,45 +380,51 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testGetTaxaByNameAndArea() { - - Set namedAreas = new HashSet(); + TaxonNode subtree = null; + Set namedAreas = new HashSet<>(); namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid)); - Classification taxonmicTree = classificationDao.findByUuid(classificationUuid); + Classification classification = classificationDao.findByUuid(classificationUuid); // prepare some synonym relation ships for some tests Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz); Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera); - taxonRethera.addSynonym(synAtroposAgassiz, SynonymRelationshipType.SYNONYM_OF()); - logger.warn("addSynonym(..)"); - //this.taxonDao.clear(); + taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF()); +// logger.warn("addSynonym(..)"); + Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach); - Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest); - taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymRelationshipType.SYNONYM_OF()); - this.taxonDao.save(taxonRetheraSecCdmtest); - //this.taxonDao.clear(); + Taxon taxonRetheraSecCdmTest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest); + taxonRetheraSecCdmTest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF()); + this.taxonDao.save(taxonRetheraSecCdmTest); + Taxon test = (Taxon)this.taxonDao.findByUuid(retheraSecCdmtest); - Set synonyms = test.getSynonyms(); +// Set synonyms3 = test.getSynonyms(); // 1. searching for a taxon (Rethera) //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas); - List results = taxonDao.getTaxaByName(true,false, false, "Rethera", null, MatchMode.BEGINNING, namedAreas, - null, null, null); + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", null, subtree, MatchMode.BEGINNING, namedAreas, + includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "com*", null, subtree, MatchMode.BEGINNING, namedAreas, + includeUnpublished, null, null, null, null); + assertNotNull("getTaxaByName should return a List", results); + assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); + // 2. searching for a taxon (Rethera) contained in a specific classification - results = taxonDao.getTaxaByName(true, false, false, "Rethera", taxonmicTree, MatchMode.BEGINNING, namedAreas, - null, null, null); + results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", classification, subtree, MatchMode.BEGINNING, namedAreas, + includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); // 3. searching for Synonyms - results = taxonDao.getTaxaByName(false, true, false, "Atropo", null, MatchMode.ANYWHERE, null, - null, null, null); + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Atropo", null, subtree, MatchMode.ANYWHERE, null, + includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); /*System.err.println(results.get(0).getTitleCache() + " - " +results.get(1).getTitleCache() + " - " +results.get(2).getTitleCache() ); @@ -414,31 +434,31 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3); // 4. searching for Synonyms - results = taxonDao.getTaxaByName(false, true, false, "Atropo", null, MatchMode.BEGINNING, null, - null, null, null); + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false,"Atropo", null, subtree, MatchMode.BEGINNING, null, + includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3); // 5. searching for a Synonyms and Taxa - // create a synonym relationship first - results = taxonDao.getTaxaByName(true, true, false, "A", null, MatchMode.BEGINNING, namedAreas, - null, null, null); + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,"A", null, subtree, MatchMode.BEGINNING, namedAreas, + includeUnpublished, null, null, null, null); //only five taxa have a distribution assertNotNull("getTaxaByName should return a List", results); - assertTrue("expected to find 7 taxa but found "+results.size(), results.size() == 8); + assertTrue("expected to find 8 taxa but found "+results.size(), results.size() == 8); } /** - * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Classclazz, String queryString, Classification classification, MatchMode matchMode, Set namedAreas, Integer pageNumber, Integer pageSize, List propertyPaths)} + * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Classclazz, String queryString, Classification classification, TaxonNode subtree, MatchMode matchMode, Set namedAreas, Integer pageNumber, Integer pageSize, List propertyPaths)} * restricting the search by a set of Areas. */ @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testFindByNameTitleCache() { + TaxonNode subtree = null; - Set namedAreas = new HashSet(); + Set namedAreas = new HashSet<>(); namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid)); @@ -448,51 +468,50 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { // prepare some synonym relation ships for some tests Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz); Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera); - taxonRethera.addSynonym(synAtroposAgassiz, SynonymRelationshipType.SYNONYM_OF()); - logger.warn("addSynonym(..)"); + taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF()); + //logger.warn("addSynonym(..)"); this.taxonDao.clear(); Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach); Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest); - taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymRelationshipType.SYNONYM_OF()); + taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF()); this.taxonDao.clear(); + // 1. searching for a taxon (Rethera) //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas); - List results = taxonDao.findByNameTitleCache(true, false, "Rethera Rothschild & Jordan, 1903", null, MatchMode.EXACT, namedAreas, - null, null, null); + @SuppressWarnings("rawtypes") + List results = taxonDao.findByNameTitleCache(doTaxa, noSynonyms, includeUnpublished, "Rethera Rothschild & Jordan, 1903", null, subtree, MatchMode.EXACT, namedAreas, + null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); // 2. searching for a taxon (Rethera) contained in a specific classification - results = taxonDao.findByNameTitleCache(true, false, "Rethera Rothschild & Jordan, 1903", classification, MatchMode.EXACT, namedAreas, - null, null, null); + results = taxonDao.findByNameTitleCache(doTaxa, noSynonyms, includeUnpublished, "Rethera Rothschild & Jordan, 1903", classification, subtree, MatchMode.EXACT, namedAreas, + null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); - // 3. searching for Synonyms - results = taxonDao.findByNameTitleCache(false, true, "*Atropo", null, MatchMode.ANYWHERE, null, - null, null, null); + results = taxonDao.findByNameTitleCache(noTaxa, doSynonyms, includeUnpublished, "*Atropo", null, subtree, MatchMode.ANYWHERE, null, + null, null, null, null); assertNotNull("getTaxaByName should return a List", results); - assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); // 4. searching for Synonyms - results = taxonDao.findByNameTitleCache(false, true, "Atropo", null, MatchMode.BEGINNING, null, - null, null, null); + results = taxonDao.findByNameTitleCache(noTaxa, doSynonyms, includeUnpublished, "Atropo", null, subtree, MatchMode.BEGINNING, null, + null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); - // 5. searching for a Synonyms and Taxa - // create a synonym relationship first + // attache a synonym first Synonym syn = (Synonym)taxonDao.findByUuid(this.atroposLeach); Taxon tax = (Taxon) taxonDao.findByUuid(rethera); - tax.addSynonym(syn, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF()); + tax.addSynonym(syn, SynonymType.HETEROTYPIC_SYNONYM_OF()); taxonDao.save(tax); - results = taxonDao.findByNameTitleCache(true, true, "A", null, MatchMode.BEGINNING, namedAreas, - null, null, null); + results = taxonDao.findByNameTitleCache(doTaxa, doSynonyms, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, namedAreas, + null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find 8 taxa but found "+results.size(), results.size() == 8); } @@ -500,10 +519,12 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testTaxonNameInTwoClassifications(){ - int numberOfClassifications = classificationDao.count(); - List propertyPaths = new ArrayList(); + TaxonNode subtree = null; + List propertyPaths = new ArrayList<>(); propertyPaths.add("taxonNodes"); - List taxa = taxonDao.getTaxaByName(true, true, false, "P", null, MatchMode.BEGINNING, null, null, null, null); + @SuppressWarnings("rawtypes") + List taxa = taxonDao.getTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,"P", null, subtree, MatchMode.BEGINNING, + null, includeUnpublished, null, null, null, null); Taxon taxon = (Taxon)taxa.get(0); Set nodes = taxon.getTaxonNodes(); assertTrue(nodes.size() == 1); @@ -511,18 +532,44 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { //assertTrue(taxa.size() > 0); } + @Test + @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") + public void testGetTaxaByNameProParteSynonym(){ + TaxonNode subtree = null; + @SuppressWarnings("rawtypes") + List taxa = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); + Assert.assertEquals("2 synonyms and 1 pro parte synonym should be returned.", 3, taxa.size()); + assertTrue("Pro parte should exist", existsInCollection(taxa, acherontiaLachesis)); + assertTrue("Normal synonym should exist", existsInCollection(taxa, atroposAgassiz)); + assertTrue("2. normal synonym should exist", existsInCollection(taxa, atroposOken)); + //TODO shouldn't we also find orphaned synonyms (without accepted taxon) like Atropos Leach? + + taxa = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, NO_UNPUBLISHED, null, null, null, null); + Assert.assertEquals("2 synonyms and no pro parte synonym should be returned.", 2, taxa.size()); + assertTrue("Normal synonym should exist", existsInCollection(taxa, atroposAgassiz)); + assertTrue("2. normal synonym should exist", existsInCollection(taxa, atroposOken)); + + taxa = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); + Assert.assertEquals("1 misapplied name, no pro parte synonym should be returned.", 1, taxa.size()); + assertTrue("Pro parte should exist", existsInCollection(taxa, aus)); + + } + @Test @DataSet public void testFindByUuid() { Taxon taxon = (Taxon)taxonDao.findByUuid(uuid); - assertNotNull("findByUuid should return a taxon",taxon); + assertNotNull("findByUuid should return a taxon", taxon); assertFalse("findByUuid should not return a taxon with it's name initialized",Hibernate.isInitialized(taxon.getName())); } @Test @DataSet public void testLoad() { - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("sec"); Taxon taxon = (Taxon)taxonDao.load(uuid, propertyPaths); @@ -533,31 +580,61 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet - public void testCountTaxonRelationships() { + public void testCountTaxonRelationshipsByTaxon() { Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon must exist"; - int numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo); - assertEquals("countTaxonRelationships should return 23", 23, numberOfRelatedTaxa); + long numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, TaxonRelationship.Direction.relatedTo); + assertEquals("countTaxonRelationships should return 8", 8, numberOfRelatedTaxa); } @Test @DataSet public void testCountTaxaByName() { - long numberOfTaxa = taxonDao.countTaxaByName(true, false, false, "A", null, MatchMode.BEGINNING, null); - assertEquals(numberOfTaxa, 9); - numberOfTaxa = taxonDao.countTaxaByName(true, false, false, "Aus aus", null, MatchMode.EXACT, null); - assertEquals(numberOfTaxa, 1); - numberOfTaxa = taxonDao.countTaxaByName(false, true, false, "A", null, MatchMode.BEGINNING, null); - assertEquals(numberOfTaxa, 3); - numberOfTaxa = taxonDao.countTaxaByName(true, true, false, "A", null, MatchMode.BEGINNING, null); - assertEquals(numberOfTaxa,12); - numberOfTaxa = taxonDao.countTaxaByName(true, true, false, "Aasfwerfwf fffe", null, MatchMode.BEGINNING, null); - assertEquals(numberOfTaxa, 0); -// FIXME implement test for search in specific classification -// Reference reference = referenceDao.findByUuid(UUID.fromString("596b1325-be50-4b0a-9aa2-3ecd610215f2")); -// numberOfTaxa = taxonDao.countTaxaByName("A*", MatchMode.BEGINNING, SelectMode.ALL, null, null); -// assertEquals(numberOfTaxa, 2); + TaxonNode subtree = null; + Classification classification= null; + long numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames,false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(5, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "S", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Sphingidae, Smerinthus, Smerinthus kindermannii and Sphingonaepiopsis expected", 4, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Smerinthus kindermannii", classification, subtree, MatchMode.EXACT, null, includeUnpublished); + assertEquals(1, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(2, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(7, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Aasfwerfwf fffe", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(0, numberOfTaxa); + + subtree = taxonNodeDao.findByUuid(UUID_ACHERONTIA_NODE); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Acherontia and 2 A. species expected", 3, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "S", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("", 0, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Smerinthus kindermannii", classification, subtree, MatchMode.EXACT, null, includeUnpublished); + assertEquals("Smerinthus is not in subtree", 0, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Atropos Agassiz and Atropos Oken expected as Synonyms", 2, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("The above accepted and synonyms expected", 5, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Aasfwerfwf fffe", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(0, numberOfTaxa); + + classification = classificationDao.findByUuid(UUID_CLASSIFICATION2); + subtree = null; + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Acherontia and 2 A. species expected", 3, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "S", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Sphingidae expected", 1, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Smerinthus kindermannii", classification, subtree, MatchMode.EXACT, null, includeUnpublished); + assertEquals("Smerinthus is not in subtree", 0, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("Atropos Agassiz and Atropos Oken expected as Synonyms", 2, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals("The above accepted and synonyms expected", 5, numberOfTaxa); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Aasfwerfwf fffe", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); + assertEquals(0, numberOfTaxa); } @Test @@ -566,22 +643,27 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon must exist"; - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("fromTaxon"); propertyPaths.add("fromTaxon.name"); - List orderHints = new ArrayList(); + List orderHints = new ArrayList<>(); orderHints.add(new OrderHint("relatedFrom.name.genusOrUninomial", SortOrder.ASCENDING)); orderHints.add(new OrderHint("relatedFrom.name.specificEpithet", SortOrder.ASCENDING)); orderHints.add(new OrderHint("relatedFrom.name.infraSpecificEpithet", SortOrder.ASCENDING)); - List relatedTaxa = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); + long count = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, TaxonRelationship.Direction.relatedTo); + assertEquals("Count should return 8 (related taxa)", 8, count); + + List relatedTaxa = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); assertNotNull("getRelatedTaxa should return a List",relatedTaxa); - assertEquals("getRelatedTaxa should return all 23 related taxa",relatedTaxa.size(),23); + assertEquals("getRelatedTaxa should return all 8 related taxa", 8, relatedTaxa.size()); assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon())); assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon().getName())); assertEquals("Acherontia should appear first in the list of related taxa", relatedTaxa.get(0).getFromTaxon().getTitleCache(), "Acherontia Laspeyres, 1809 sec. cate-sphingidae.org"); - assertEquals("Sphingonaepiopsis should appear last in the list of related taxa", relatedTaxa.get(22).getFromTaxon().getTitleCache(), "Sphinx Linnaeus, 1758 sec. cate-sphingidae.org"); + assertEquals("Sphingonaepiopsis should appear last in the list of related taxa", "Sphingonaepiopsis Wallengren, 1858 sec. cate-sphingidae.org", relatedTaxa.get(relatedTaxa.size()-1).getFromTaxon().getTitleCache()); } @Test @@ -590,89 +672,135 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon must exist"; - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("fromTaxon"); propertyPaths.add("fromTaxon.name"); - List orderHints = new ArrayList(); + List orderHints = new ArrayList<>(); orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING)); - List firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); - List secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),10, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); - List thirdPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 2, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); - - assertNotNull("getRelatedTaxa: 10, 0 should return a List",firstPage); - assertEquals("getRelatedTaxa: 10, 0 should return a List with 10 elements",10,firstPage.size()); - assertNotNull("getRelatedTaxa: 10, 1 should return a List",secondPage); - assertEquals("getRelatedTaxa: 10, 1 should return a List with 10 elements",secondPage.size(),10); - assertNotNull("getRelatedTaxa: 10, 2 should return a List",thirdPage); - assertEquals("getRelatedTaxa: 10, 2 should return a List with 3 elements",thirdPage.size(),3); + int pageSize = 3; + List firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, pageSize, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); + List secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, pageSize, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); + List thirdPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, pageSize, 2, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo); + + assertNotNull("getRelatedTaxa: 3, 0 should return a List",firstPage); + assertEquals("getRelatedTaxa: 3, 0 should return a List with 3 elements", pageSize,firstPage.size()); + assertNotNull("getRelatedTaxa: 3, 1 should return a List",secondPage); + assertEquals("getRelatedTaxa: 3, 1 should return a List with 3 elements", pageSize, secondPage.size()); + assertNotNull("getRelatedTaxa: 3, 2 should return a List",thirdPage); + assertEquals("getRelatedTaxa: 3, 2 should return a List with 2 elements", 2, thirdPage.size()); } @Test @DataSet - public void testCountSynonymRelationships() { + public void testCountSynonyms() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); assert taxon != null : "taxon must exist"; - int numberOfSynonymRelationships = taxonDao.countSynonyms(taxon,null); - assertEquals("countSynonymRelationships should return 5",5,numberOfSynonymRelationships); + long numberOfRelatedSynonym = taxonDao.countSynonyms(taxon,null); + assertEquals("countSynonyms should return 3", 3, numberOfRelatedSynonym); } @Test @DataSet - public void testSynonymRelationships() { + public void testGetSynonyms() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); assert taxon != null : "taxon must exist"; List propertyPaths = new ArrayList(); propertyPaths.add("synonym"); propertyPaths.add("synonym.name"); - List orderHints = new ArrayList(); - orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING)); + List orderHints = new ArrayList<>(); + orderHints.add(new OrderHint("titleCache", SortOrder.ASCENDING)); - List synonyms = taxonDao.getSynonyms(taxon, null, null, null,orderHints,propertyPaths); + List synonyms = taxonDao.getSynonyms(taxon, null, null, null,orderHints,propertyPaths); - assertNotNull("getSynonyms should return a List",synonyms); - assertEquals("getSynonyms should return 5 SynonymRelationship entities",synonyms.size(),5); - assertTrue("getSynonyms should return SynonymRelationship objects with the synonym initialized",Hibernate.isInitialized(synonyms.get(0).getSynonym())); + assertNotNull("getSynonyms should return a List", synonyms); + assertEquals("getSynonyms should return 3 synonyms", 3, synonyms.size()); + assertTrue("getSynonyms should return synonym objects with the synonym initialized", Hibernate.isInitialized(synonyms.get(0))); } @Test @DataSet - public void testCountSynonymRelationshipsByType() { + public void testCountSynonymsByType() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); assert taxon != null : "taxon must exist"; - int numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF()); - assertEquals("countSynonyms should return 4",numberOfTaxonomicSynonyms, 4); + long numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF()); + assertEquals("countSynonyms should return 4", 3, numberOfTaxonomicSynonyms); } @Test @DataSet - public void testSynonymRelationshipsByType() { + public void testSynonymsByType() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); assert taxon != null : "taxon must exist"; - List synonyms = taxonDao.getSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), null, null,null,null); + List synonyms = taxonDao.getSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF(), null, null,null,null); - assertNotNull("getSynonyms should return a List",synonyms); - assertEquals("getSynonyms should return 4 SynonymRelationship entities",synonyms.size(),4); + assertNotNull("getSynonyms should return a List", synonyms); + assertEquals("getSynonyms should return 4 Synonyms", 3, synonyms.size()); } @Test @DataSet - public void testPageSynonymRelationships(){ + public void testPageSynonyms(){ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); assert taxon != null : "taxon must exist"; - List firstPage = taxonDao.getSynonyms(taxon, null, 4, 0,null,null); - List secondPage = taxonDao.getSynonyms(taxon, null, 4, 1,null,null); + int pageSize = 2; + List firstPage = taxonDao.getSynonyms(taxon, null, pageSize, 0,null,null); + List secondPage = taxonDao.getSynonyms(taxon, null, pageSize, 1,null,null); - assertNotNull("getSynonyms: 4, 0 should return a List",firstPage); - assertEquals("getSynonyms: 4, 0 should return 4 SynonymRelationships", 4,firstPage.size()); - assertNotNull("getSynonyms: 4, 1 should return a List",secondPage); - assertEquals("getSynonyms: 4, 1 should return 1 SynonymRelationship", 1, secondPage.size()); + assertNotNull("getSynonyms: 2, 0 should return a List",firstPage); + assertEquals("getSynonyms: 2, 0 should return 2 synonyms", pageSize,firstPage.size()); + assertNotNull("getSynonyms: 2, 1 should return a List",secondPage); + assertEquals("getSynonyms: 2, 1 should return 1 synonym", 1, secondPage.size()); + } + + @Test + @DataSet + public void testCountTaxonRelationships() { + long count = taxonDao.countTaxonRelationships(null); + assertEquals("There should be 11 relationships", 11, count); + + Set types = new HashSet<>(); + count = taxonDao.countTaxonRelationships(types); + assertEquals("Empty filter should return empty result", 0, count); + + types.add(TaxonRelationshipType.CONGRUENT_TO()); + count = taxonDao.countTaxonRelationships(types); + assertEquals("There should be no congruent relationship", 0, count); + + types.add(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN()); + count = taxonDao.countTaxonRelationships(types); + assertEquals("There should be 11 tax included relationships", 11, count); + } + + @Test + @DataSet + public void testlistTaxonRelationships() { + List rels = taxonDao.getTaxonRelationships(null, null, null, null, null); + assertEquals("There should be 11 relationships", 11, rels.size()); + + rels = taxonDao.getTaxonRelationships(null, 2, 3, null, null); + assertEquals("There should be 11 relationships", 2, rels.size()); + + Set types = new HashSet<>(); + rels = taxonDao.getTaxonRelationships(types, null, null, null, null); + assertEquals("Empty filter should return empty result", 0, rels.size()); + + types.add(TaxonRelationshipType.CONGRUENT_TO()); + rels = taxonDao.getTaxonRelationships(types, null, null, null, null); + assertEquals("There should be no congruent relationship", 0, rels.size()); + + types.add(TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN()); + rels = taxonDao.getTaxonRelationships(types, null, null, null, null); + assertEquals("There should be 11 tax included relationships", 11, rels.size()); } @Test @@ -683,23 +811,22 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Synonym synonym = (Synonym)taxonDao.findByUuid(acheontitia_ciprosus); assertNotNull("synonym must exist", synonym); - List list = taxonDao.listAcceptedTaxaFor(synonym, null, 4, 0, null, null); - assertNotNull("listAcceptedTaxaFor should return a List"); - assertEquals("listAcceptedTaxaFor should return 2 Taxa", 2, list.size()); + Taxon taxon = taxonDao.acceptedTaxonFor(synonym, null, null); + assertNotNull("listAcceptedTaxaFor should return a taxon", taxon); Classification classification = classificationDao.load(classificationUuid); assertNotNull("classification must exist", classification); - list = taxonDao.listAcceptedTaxaFor(synonym, classification, 4, 0, null, null); - assertNotNull("listAcceptedTaxaFor should return a List"); - assertEquals("listAcceptedTaxaFor should return 1 Taxa", 1, list.size()); + taxon = taxonDao.acceptedTaxonFor(synonym, classification, null); + assertNull("listAcceptedTaxaFor should return not taxon due to classification filter", taxon); } @Test @DataSet public void testGetTaxonMatchingUninomial() { - List result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", "*", "*", "*",null,null,null); + @SuppressWarnings("rawtypes") + List result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", "*", "*", "*","*",null,null,null); assertNotNull("findTaxaByName should return a List", result); assertEquals("findTaxaByName should return two Taxa",2,result.size()); @@ -709,7 +836,8 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxonMatchingSpeciesBinomial() { - List result = taxonDao.findTaxaByName(Taxon.class,"Smerinthus", null, "kindermannii", null,null,null,null); + @SuppressWarnings("rawtypes") + List result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", null, "kindermannii", null,"*",null,null,null); assertNotNull("findTaxaByName should return a List", result); assertEquals("findTaxaByName should return one Taxon",1,result.size()); @@ -719,7 +847,8 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxonMatchingTrinomial() { - List result = taxonDao.findTaxaByName(Taxon.class,"Cryptocoryne", null,"purpurea","borneoensis",null,null,null); + @SuppressWarnings("rawtypes") + List result = taxonDao.findTaxaByName(Taxon.class,"Cryptocoryne", null,"purpurea","borneoensis","*",null,null,null); assertNotNull("findTaxaByName should return a List", result); assertEquals("findTaxaByName should return one Taxon",1,result.size()); @@ -729,7 +858,8 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testNegativeMatch() { - List result = taxonDao.findTaxaByName(Taxon.class,"Acherontia", null,"atropos","dehli",null,null,null); + @SuppressWarnings("rawtypes") + List result = taxonDao.findTaxaByName(Taxon.class,"Acherontia", null,"atropos","dehli",null,null,null,null); assertNotNull("findTaxaByName should return a List", result); assertTrue("findTaxaByName should return an empty List",result.isEmpty()); @@ -738,16 +868,16 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testCountAllTaxa() { - int numberOfTaxa = taxonDao.count(Taxon.class); - assertEquals("count should return 33 taxa",33, numberOfTaxa); + long numberOfTaxa = taxonDao.count(Taxon.class); + assertEquals("count should return 14 taxa", 14, numberOfTaxa); } @Test @DataSet public void testListAllTaxa() { List taxa = taxonDao.list(Taxon.class,100, 0); - assertNotNull("list should return a List",taxa); - assertEquals("list should return 33 taxa",33, taxa.size()); + assertNotNull("list should return a List", taxa); + assertEquals("list should return 14 taxa", 14, taxa.size()); } @Test @@ -770,7 +900,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet - // @ExpectedDataSet("TaxonDaoHibernateImplTest.testDelete-result.xml") + @ExpectedDataSet("TaxonDaoHibernateImplTest.testDelete-result.xml") public void testDeleteWithMarker() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia); taxon.addMarker(Marker.NewInstance(MarkerType.IS_DOUBTFUL(), true)); @@ -790,19 +920,6 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { // } } - @Test - @DataSet - public void testDeleteWithChildren() { - Taxon taxonWithChildren = (Taxon)taxonDao.findByUuid(mimas); - assert taxonWithChildren != null : "taxon must exist"; - assertEquals(taxonWithChildren.getTaxonomicChildrenCount(), 2); - Taxon parent = (Taxon)taxonDao.findByUuid(sphingidae); - assertSame(taxonWithChildren.getTaxonomicParent(), parent); - assertEquals(parent.getTaxonomicChildrenCount(), 204); - taxonDao.delete(taxonWithChildren); - assertEquals(parent.getTaxonomicChildrenCount(), 203); - } - @Test @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml") public void testFindDeleted() { @@ -832,11 +949,12 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(taxon, null,null,null,propertyPaths); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -850,6 +968,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(taxon, null,null,AuditEventSort.FORWARDS,null); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -862,7 +981,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; - int numberOfAuditEvents = taxonDao.countAuditEvents(taxon,null); + long numberOfAuditEvents = taxonDao.countAuditEvents(taxon, null); assertEquals("countAuditEvents should return 2",numberOfAuditEvents,2); } @@ -880,9 +999,10 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml") public void getPreviousAuditEventAtBeginning() { AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent); - TaxonBase taxon = taxonDao.findByUuid(sphingidae); + TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getPreviousAuditEvent(taxon); assertNull("getPreviousAuditEvent should return null if we're at the first audit event anyway",auditEvent); } @@ -894,6 +1014,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getNextAuditEvent(taxon); assertNotNull("getNextAuditEvent should not return null as there is at least one audit event after the current one",auditEvent); } @@ -905,32 +1026,18 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getNextAuditEvent(taxon); assertNull("getNextAuditEvent should return null as there no more audit events after the current one",auditEvent); } - @Test - @DataSet - @ExpectedDataSet - public void testAddChild() throws Exception { - Taxon parent = (Taxon)taxonDao.findByUuid(acherontiaLachesis); - assert parent != null : "taxon cannot be null"; - Taxon child = Taxon.NewInstance(null, null); - child.setTitleCache("Acherontia lachesis diehli Eitschberger, 2003", true); - child.addTaxonRelation(parent, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),null, null); - taxonDao.save(child); - setComplete(); - endTransaction(); - } - @Test @DataSet("TaxonDaoHibernateImplTest.testFind.xml") public void testFind() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - assertEquals("getTaxonomicChildrenCount should return 1 in this view",1,taxon.getTaxonomicChildrenCount()); - assertEquals("getRelationsToThisTaxon should contain 1 TaxonRelationship in this view",1,taxon.getRelationsToThisTaxon().size()); + assertEquals("getRelationsToThisTaxon should contain 1 TaxonRelationship in this view",1,taxon.getRelationsToThisTaxon().size()); } @Test @@ -940,7 +1047,6 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - assertEquals("getTaxonomicChildrenCount should return 0 in this view",0,taxon.getTaxonomicChildrenCount()); assertTrue("getRelationsToThisTaxon should contain 0 TaxonRelationship in this view",taxon.getRelationsToThisTaxon().isEmpty()); } @@ -950,14 +1056,15 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("fromTaxon"); propertyPaths.add("fromTaxon.name"); - List orderHints = new ArrayList(); + List orderHints = new ArrayList<>(); orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING)); - List taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); + List taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); assertNotNull("getRelatedTaxa should return a list", taxonRelations); assertEquals("there should be one TaxonRelationship in the list in the current view",1,taxonRelations.size()); assertTrue("TaxonRelationship.relatedFrom should be initialized",Hibernate.isInitialized(taxonRelations.get(0).getFromTaxon())); @@ -969,7 +1076,9 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testCountRelations() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - assertEquals("countRelatedTaxa should return 1 in the current view",1, taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo)); + assertEquals("countRelatedTaxa should return 1 in the current view",1, taxonDao.countTaxonRelationships( + taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, TaxonRelationship.Direction.relatedTo)); } @Test @@ -983,12 +1092,13 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { propertyPaths.add("relatedFrom"); propertyPaths.add("relatedFrom.name"); - List orderHints = new ArrayList(); + List orderHints = new ArrayList<>(); orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING)); - List taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); + List taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); assertNotNull("getRelatedTaxa should return a list",taxonRelations); - assertTrue("there should be no TaxonRelationships in the list in the prior view",taxonRelations.isEmpty()); + assertTrue("there should be no TaxonRelationships in the list in the prior view", taxonRelations.isEmpty()); } @Test @@ -997,89 +1107,73 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent); Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - assertEquals("countRelatedTaxa should return 0 in the current view",0, taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo)); + assertEquals("countRelatedTaxa should return 0 in the current view",0, + taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + includeUnpublished, TaxonRelationship.Direction.relatedTo)); } @Test @DataSet public void testGroupTaxa() { - List groups = new ArrayList(); + List groups = new ArrayList<>(); groups.add(new GroupByCount("count",SortOrder.DESCENDING)); groups.add(new Grouping("name.genusOrUninomial", "genus", "n", SortOrder.ASCENDING)); List results = taxonDao.group(null, null, null, groups,null); - System.out.println("count\tname.genuOrUninomial"); - for(Object[] result : results) { - System.out.println(result[0] + "\t" + result[1]); + if(logger.isTraceEnabled()){ + System.out.println("count\tname.genuOrUninomial"); + for(Object[] result : results) { + System.out.println(result[0] + "\t" + result[1]); + } } } @Test @DataSet public void testGroupTaxaByClass() { - List groups = new ArrayList(); + List groups = new ArrayList<>(); groups.add(new GroupByCount("count",SortOrder.DESCENDING)); groups.add(new Grouping("class", "class",null, SortOrder.ASCENDING)); List results = taxonDao.group(null, null, null, groups,null); - System.out.println("count\tclass"); - for(Object[] result : results) { - System.out.println(result[0] + "\t" + result[1]); + if(logger.isTraceEnabled()){ + System.out.println("count\tclass"); + for(Object[] result : results) { + System.out.println(result[0] + "\t" + result[1]); + } } } @Test @DataSet public void testNativeSQLOrder() { - List orderHints = new ArrayList(); + List orderHints = new ArrayList<>(); orderHints.add(new NativeSqlOrderHint("case when {alias}.titleCache like 'C%' then 0 else 1 end",SortOrder.ASCENDING)); + @SuppressWarnings("rawtypes") List results = taxonDao.list(null, null, orderHints); - System.out.println("native SQL order"); - for(TaxonBase result : results) { - System.out.println(result.getTitleCache()); + if(logger.isTraceEnabled()){ + System.out.println("native SQL order"); + for(TaxonBase result : results) { + System.out.println(result.getTitleCache()); + } } } @Test @DataSet public void testGroupByDateTaxa() { - List groups = new ArrayList(); + List groups = new ArrayList<>(); groups.add(new GroupByCount("count",null)); groups.add(new GroupByDate("created", "dateGroup", SortOrder.ASCENDING, GroupByDate.Resolution.MONTH)); List results = taxonDao.group(null, null, null, groups,null); - System.out.println("count\tyear\tmonth"); - for(Object[] result : results) { - System.out.println(result[0] + "\t" + result[1] + "\t" + result[2]); + if(logger.isTraceEnabled()){ + System.out.println("count\tyear\tmonth"); + for(Object[] result : results) { + System.out.println(result[0] + "\t" + result[1] + "\t" + result[2]); + } } } - @Test - @DataSet ("TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") - public final void testGetTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(){ - Classification classification = classificationDao.findByUuid(classificationUuid); - List> result = taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, null, null, null); - assertNotNull(result); - assertEquals(5, result.size()); - - //test exclude - UUID excludeUUID = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); - List excludeUUids = new ArrayList(); - excludeUUids.add(excludeUUID); - result = taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeUUids, null, null); - assertEquals(4, result.size()); - - //test limit - int limit = 2; - result = taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, null, limit, null); - assertEquals(2, result.size()); - - //test pattern - String pattern = "*Rothschi*"; - result = taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, null, 2, pattern); - assertNotNull(result); - assertEquals(1, result.size()); - assertEquals("0b5846e5-b8d2-4ca9-ac51-099286ea4adc", result.get(0).getUuid().toString()); - } @Test @@ -1092,16 +1186,17 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testGetAuditEventsByTypeWithRestrictions() { commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); - List criteria = new ArrayList(); + List criteria = new ArrayList<>(); criteria.add(AuditEntity.property("lsid_lsid").isNotNull()); - int count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, criteria,null, null, AuditEventSort.FORWARDS, propertyPaths); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -1121,18 +1216,19 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { //while those inserted by the terms dataset are inserted as well as a completely new one. //This problem for some reason does not happen if not running at first place public void testGetAuditEventsByTypeWithNoRestrictions() { - printDataSet(System.out, new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); +// printDataSet(System.out, new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); - int count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, null,null, null, AuditEventSort.FORWARDS, propertyPaths); assertNotNull("getAuditEvents should return a list", auditEvents); assertFalse("the list should not be empty", auditEvents.isEmpty()); - assertEquals("There should be thirty eight AuditEventRecords in the list", 38, auditEvents.size()); + assertEquals("There should be thirty eight AuditEventRecords in the list", 2, auditEvents.size()); } @@ -1144,10 +1240,28 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertNotNull("getTaxaByCommonName should return a list", commonNameResults); assertFalse("the list should not be empty", commonNameResults.isEmpty()); - assertEquals("There should be one Taxon with common name", 1,commonNameResults.size()); - assertEquals(" sec. ???", ((TaxonBase)commonNameResults.get(0)).getTitleCache()); + assertEquals("There should be two taxa with common name", 2,commonNameResults.size()); + + List> list = taxonDao.getTaxaByCommonNameForEditor( + "common%", null, MatchMode.BEGINNING, null); + + assertNotNull("getTaxaByCommonName should return a list", list); + assertFalse("the list should not be empty", list.isEmpty()); + assertEquals("There should be two Taxon with common name", 2,list.size()); + } + @Test + @DataSet + public void testGetTitleCache(){ + UUID uuid = UUID.fromString("7b8b5cb3-37ba-4dba-91ac-4c6ffd6ac331"); + String titleCache = taxonDao.getTitleCache(uuid, false); + Assert.assertEquals("Acherontia styx Westwood, 1847 sec. cate-sphingidae.org", titleCache); + titleCache = taxonDao.getTitleCache(uuid, true); + Assert.assertEquals("Acherontia styxx Westwood, 1847 sec. cate-sphingidae.org", titleCache); + } + + @Test @DataSet("TaxonDaoHibernateImplTest.testPropertyPath.xml") public void testPropertyPath(){ @@ -1157,7 +1271,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxonProxy = singleNode.getTaxon(); Assert.assertTrue("Object to test should be a proxy ", taxonProxy instanceof HibernateProxy); - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("taxonNodes"); Taxon taxon = (Taxon)this.taxonDao.load( UUID.fromString("4a5bc930-844f-45ec-aea8-dd155e1ab25f"), @@ -1165,6 +1279,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Assert.assertSame("Returned object should be the same proxy to assure that we ran initialization on this proxy", taxonProxy, taxon); } + /** * {@inheritDoc} */ @@ -1172,16 +1287,16 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { // @Test public void createTestDataSet() throws FileNotFoundException { // Classification classification = Classification.NewInstance("Test"); -// BotanicalName taxonNameBase = null; +// BotanicalName TaxonName = null; // Reference sec = null; -// Taxon taxon = Taxon.NewInstance(taxonNameBase, sec); +// Taxon taxon = Taxon.NewInstance(taxonName, sec); // classification.addChildTaxon(taxon, sec, null); // // classificationDao.save(classification); // this.commitAndStartNewTransaction(null); // // writeDbUnitDataSetFile(new String[] { -// "CLASSIFICATION", "TAXONNAMEBASE", +// "CLASSIFICATION", "TAXONNAME", // "REFERENCE","TAXONNODE", // "TAXONBASE","LANGUAGESTRING", // "HIBERNATE_SEQUENCES" // IMPORTANT!!!