-/**\r
-* Copyright (C) 2009 EDIT\r
-* European Distributed Institute of Taxonomy\r
-* http://www.e-taxonomy.eu\r
-*\r
-* The contents of this file are subject to the Mozilla Public License Version 1.1\r
-* See LICENSE.TXT at the top of this package for the full license terms.\r
-*/\r
-\r
-package eu.etaxonomy.cdm.persistence.dao.hibernate.taxon;\r
-\r
-import static org.junit.Assert.assertEquals;\r
-import static org.junit.Assert.assertFalse;\r
-import static org.junit.Assert.assertNotNull;\r
-import static org.junit.Assert.assertNull;\r
-import static org.junit.Assert.assertSame;\r
-import static org.junit.Assert.assertTrue;\r
-import static org.junit.Assert.fail;\r
-\r
-import java.io.FileNotFoundException;\r
-import java.io.FileOutputStream;\r
-import java.util.ArrayList;\r
-import java.util.HashSet;\r
-import java.util.List;\r
-import java.util.Set;\r
-import java.util.UUID;\r
-\r
-import org.apache.log4j.Level;\r
-import org.hibernate.Hibernate;\r
-import org.hibernate.envers.query.AuditEntity;\r
-import org.hibernate.envers.query.criteria.AuditCriterion;\r
-import org.junit.After;\r
-import org.junit.Assert;\r
-import org.junit.Before;\r
-import org.junit.Ignore;\r
-import org.junit.Test;\r
-import org.unitils.dbunit.annotation.DataSet;\r
-import org.unitils.dbunit.annotation.ExpectedDataSet;\r
-import org.unitils.spring.annotation.SpringBeanByType;\r
-\r
-import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
-import eu.etaxonomy.cdm.model.common.Marker;\r
-import eu.etaxonomy.cdm.model.common.MarkerType;\r
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;\r
-import eu.etaxonomy.cdm.model.location.NamedArea;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
-import eu.etaxonomy.cdm.model.name.Rank;\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
-import eu.etaxonomy.cdm.model.reference.Reference;\r
-import eu.etaxonomy.cdm.model.taxon.Classification;\r
-import eu.etaxonomy.cdm.model.taxon.Synonym;\r
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;\r
-import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;\r
-import eu.etaxonomy.cdm.model.taxon.Taxon;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;\r
-import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
-import eu.etaxonomy.cdm.model.view.AuditEvent;\r
-import eu.etaxonomy.cdm.model.view.AuditEventRecord;\r
-import eu.etaxonomy.cdm.model.view.context.AuditEventContextHolder;\r
-import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;\r
-import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;\r
-import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;\r
-import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;\r
-import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;\r
-import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;\r
-import eu.etaxonomy.cdm.persistence.query.GroupByCount;\r
-import eu.etaxonomy.cdm.persistence.query.GroupByDate;\r
-import eu.etaxonomy.cdm.persistence.query.Grouping;\r
-import eu.etaxonomy.cdm.persistence.query.MatchMode;\r
-import eu.etaxonomy.cdm.persistence.query.NativeSqlOrderHint;\r
-import eu.etaxonomy.cdm.persistence.query.OrderHint;\r
-import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;\r
-import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;\r
-import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;\r
-\r
-/**\r
- * @author a.mueller\r
- * @author ben.clark\r
- *\r
- */\r
-public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest {\r
-\r
- @SpringBeanByType\r
- private ITaxonDao taxonDao;\r
-\r
- @SpringBeanByType\r
- private IClassificationDao classificationDao;\r
-\r
- @SpringBeanByType\r
- private IReferenceDao referenceDao;\r
-\r
- @SpringBeanByType\r
- IDefinedTermDao definedTermDao;\r
-\r
- private UUID uuid;\r
- private UUID sphingidae;\r
- private UUID acherontia;\r
- private UUID mimas;\r
- private UUID rethera;\r
- private UUID retheraSecCdmtest;\r
- private UUID atroposAgassiz;\r
- private UUID atroposLeach;\r
- private UUID acherontiaLachesis;\r
- private AuditEvent previousAuditEvent;\r
- private AuditEvent mostRecentAuditEvent;\r
-\r
- private UUID northernAmericaUuid;\r
- private UUID southernAmericaUuid;\r
- private UUID antarcticaUuid;\r
-\r
- private UUID classificationUuid;\r
-\r
- private static final String[] TABLE_NAMES = new String[] {\r
- "HOMOTYPICALGROUP", "HOMOTYPICALGROUP_AUD", "REFERENCE", "REFERENCE_AUD", "SYNONYMRELATIONSHIP", "SYNONYMRELATIONSHIP_AUD", "TAXONBASE", "TAXONBASE_AUD"\r
- , "TAXONNAMEBASE", "TAXONNAMEBASE_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" };\r
-\r
-\r
- @Before\r
- public void setUp() {\r
-\r
- uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2");\r
- sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9");\r
- acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa");\r
- acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06");\r
- atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1");\r
- atroposLeach = UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07");\r
- rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae");\r
- retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae");\r
-\r
-\r
- mimas = UUID.fromString("900052b7-b69c-4e26-a8f0-01c215214c40");\r
- previousAuditEvent = new AuditEvent();\r
- previousAuditEvent.setRevisionNumber(1025);\r
- previousAuditEvent.setUuid(UUID.fromString("a680fab4-365e-4765-b49e-768f2ee30cda"));\r
- mostRecentAuditEvent = new AuditEvent();\r
- mostRecentAuditEvent.setRevisionNumber(1026);\r
- mostRecentAuditEvent.setUuid(UUID.fromString("afe8e761-8545-497b-9134-6a6791fc0b0d"));\r
- AuditEventContextHolder.clearContext(); // By default we're in the current view (i.e. view == null)\r
-\r
- northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f");\r
- southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea");\r
- antarcticaUuid = UUID.fromString("791b3aa0-54dd-4bed-9b68-56b4680aad0c");\r
-\r
- classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");\r
- }\r
-\r
- @After\r
- public void tearDown() {\r
- AuditEventContextHolder.clearContext();\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#TaxonDaoHibernateImpl()}.\r
- */\r
- @Test\r
- @DataSet\r
- public void testInit() {\r
- logger.warn("testInit()");\r
- assertNotNull("Instance of ITaxonDao expected",taxonDao);\r
- assertNotNull("Instance of IReferenceDao expected",referenceDao);\r
- }\r
-\r
- /**\r
- * Test method for\r
- * {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getRootTaxa(eu.etaxonomy.cdm.model.reference.Reference)}\r
- * .\r
- */\r
- @Test\r
- @DataSet\r
- public void testGetRootTaxa() {\r
- Reference sec1 = referenceDao.findById(1);\r
- assert sec1 != null : "sec1 must exist";\r
- Reference sec2 = referenceDao.findById(2);\r
- assert sec2 != null : "sec2 must exist";\r
-\r
- List<Taxon> rootTaxa = taxonDao.getRootTaxa(sec1);\r
- assertNotNull("getRootTaxa should return a List", rootTaxa);\r
- assertFalse("The list should not be empty", rootTaxa.isEmpty());\r
- assertEquals("There should be one root taxon", 1, rootTaxa.size());\r
-\r
- rootTaxa = taxonDao.getRootTaxa(sec1, CdmFetch.FETCH_CHILDTAXA(), true, false);\r
- assertNotNull("getRootTaxa should return a List", rootTaxa);\r
- assertFalse("The list should not be empty", rootTaxa.isEmpty());\r
- assertEquals("There should be one root taxon", 1, rootTaxa.size());\r
-\r
- rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec1, CdmFetch.FETCH_CHILDTAXA(), true, false, null);\r
- assertNotNull("getRootTaxa should return a List", rootTaxa);\r
- assertFalse("The list should not be empty", rootTaxa.isEmpty());\r
- assertEquals("There should be one root taxon", 1, rootTaxa.size());\r
-\r
- rootTaxa = taxonDao.getRootTaxa(Rank.FAMILY(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);\r
- if (logger.isDebugEnabled()) {\r
- logger.debug("Root taxa rank Family (" + rootTaxa.size() + "):");\r
- for (Taxon taxon : rootTaxa) {\r
- logger.debug(taxon.getTitleCache());\r
- }\r
- }\r
- assertEquals("There should be one root taxon rank Family", 1, rootTaxa.size());\r
- rootTaxa = taxonDao.getRootTaxa(Rank.GENUS(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);\r
- assertNotNull("getRootTaxa should return a List", rootTaxa);\r
- assertFalse("The list should not be empty", rootTaxa.isEmpty());\r
- if (logger.isDebugEnabled()) {\r
- logger.debug("Root taxa rank Genus (" + rootTaxa.size() + "):");\r
- for (Taxon taxon : rootTaxa) {\r
- logger.debug(taxon.getTitleCache());\r
- }\r
- }\r
- assertEquals("There should be 22 root taxa rank Genus", 22, rootTaxa.size());\r
-\r
- rootTaxa = taxonDao.getRootTaxa(Rank.SPECIES(), sec2, CdmFetch.FETCH_CHILDTAXA(), true, false, null);\r
- if (logger.isDebugEnabled()) {\r
- logger.debug("Root taxa rank Species (" + rootTaxa.size() + "):");\r
- for (Taxon taxon : rootTaxa) {\r
- logger.debug(taxon.getTitleCache());\r
- }\r
- }\r
- assertEquals("There should be 4 root taxa rank Species", 3, rootTaxa.size());\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}.\r
- */\r
- @Test\r
- @DataSet\r
- public void testGetTaxaByName() {\r
- Reference<?> sec = referenceDao.findById(1);\r
- assert sec != null : "sec must exist";\r
-\r
- List<TaxonBase> results = taxonDao.getTaxaByName("Aus", sec);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- //assertFalse("The list should not be empty", results.isEmpty());\r
- assertTrue(results.size() == 1);\r
-\r
- results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, true, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
-\r
- int numberOfTaxaByName_A = 9;\r
-\r
- logger.setLevel(Level.DEBUG); //FIXME #######################\r
- if (logger.isDebugEnabled()) {\r
- for (int i = 0; i < results.size(); i++) {\r
- String nameCache = "";\r
- TaxonNameBase<?,?> taxonNameBase= results.get(i).getName();\r
- nameCache = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class).getNameCache();\r
- logger.debug(results.get(i).getClass() + "(" + i +")" +\r
- ": Name Cache = " + nameCache + ", Title Cache = " + results.get(i).getTitleCache());\r
- }\r
- }\r
-\r
- assertEquals(numberOfTaxaByName_A, results.size());\r
-\r
-\r
- //System.err.println("Species group: " + Rank.SPECIESGROUP().getId() + "Species: " + Rank.SPECIES().getId() + "Section Botany: "+ Rank.SECTION_BOTANY());\r
-\r
-// assertEquals(results.get(0).getTitleCache(), "Abies sec. ???");\r
-// assertEquals(results.get(1).getTitleCache(), "Abies Mill.");\r
-// assertEquals(results.get(2).getTitleCache(), "Abies mill. sec. ???");\r
-// assertEquals(results.get(3).getTitleCache(), "Abies alba sec. ???");\r
-// assertEquals(results.get(4).getTitleCache(), "Abies alba Michx. sec. ???");\r
-// assertEquals(results.get(5).getTitleCache(), "Abies alba Mill. sec. ???");\r
-\r
- results = taxonDao.getTaxaByName("A", MatchMode.BEGINNING, true, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertEquals(numberOfTaxaByName_A, results.size());\r
-\r
- results = taxonDao.getTaxaByName("Aus", MatchMode.EXACT, true, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertEquals("Results list should contain one entity",1,results.size());\r
- }\r
-\r
-\r
- @Test\r
- //@Ignore\r
- @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public void testGetTaxaByNameWithMisappliedNames(){\r
-\r
- Classification classification = classificationDao.load(classificationUuid);\r
-\r
- /* NOTE:\r
- * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis), two contained in the classification used in this test,\r
- * the other one is not contained in any classification. This latter case is the more general situation.\r
- * Misapplied names should be found regardless of whether they are contained in a classification or not.\r
- */\r
- //two accepted taxa starting with R in classification "TestBaum"\r
- List<TaxonBase> results = taxonDao.getTaxaByName(true, false, false, "R*", classification, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 2 Taxa", 2, results.size());\r
-\r
- //three taxa, 2 accepted and 1 misapplied name starting with R\r
- results = taxonDao.getTaxaByName(true, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 3 Taxa", 3, results.size());\r
-\r
- //one synonym is not in a synonymrelationship\r
- results = taxonDao.getTaxaByName(true, true, true, "A*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 11 Taxa",11, results.size());\r
-\r
- //two accepted taxa in classification and 1 misapplied name with accepted name in classification\r
- results = taxonDao.getTaxaByName(true, true, true, "R*", classification, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 3 Taxa", 3, results.size());\r
-\r
- //same as above because all taxa, synonyms and misapplied names starting with R are in the classification\r
- results = taxonDao.getTaxaByName(true, true, true, "R*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 3 Taxa", 3, results.size());\r
-\r
- //find misapplied names with accepted taxon in the classification, the accepted taxa of two misapplied names are in the classification\r
- results = taxonDao.getTaxaByName(false, false, true, "*", classification, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 2 Taxa", 2, results.size());\r
-\r
- //find misapplied names beginning with R\r
- results = taxonDao.getTaxaByName(false, false, true, "R*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 1 Taxa", 1, results.size());\r
-\r
- //find all three misapplied names\r
- results = taxonDao.getTaxaByName(false, false, true, "*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Assert.assertEquals("There should be 3 Taxa", 3, results.size());\r
-\r
- }\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}.\r
- */\r
- @Test\r
- @DataSet\r
- public void testGetTaxaByNameForEditor() {\r
- Reference<?> sec = referenceDao.findById(1);\r
- assert sec != null : "sec must exist";\r
-\r
- List<UuidAndTitleCache<TaxonBase>> results = taxonDao.getTaxaByNameForEditor(true, true, "Mand*", null, MatchMode.BEGINNING, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- //assertFalse("The list should not be empty", results.isEmpty());\r
- assertTrue(results.size() == 5);\r
-\r
-\r
- results = taxonDao.getTaxaByNameForEditor(true, true,"A*",null, MatchMode.BEGINNING, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertEquals(results.size(), 12);\r
-\r
-\r
- results = taxonDao.getTaxaByNameForEditor(true, false,"A", null,MatchMode.BEGINNING, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue(results.size() == 9);\r
- assertEquals(results.get(0).getType(), Taxon.class);\r
-\r
- results = taxonDao.getTaxaByNameForEditor(false, true,"A", null,MatchMode.BEGINNING, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue(results.size() == 3);\r
- assertEquals(results.get(0).getType(), Synonym.class);\r
-\r
- results = taxonDao.getTaxaByNameForEditor(true, true,"Aus", null,MatchMode.EXACT, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertEquals("Results list should contain one entity",1,results.size());\r
- }\r
-\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}\r
- * restricting the search by a set of Areas.\r
- */\r
- @Test\r
- @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public void testGetTaxaByNameAndArea() {\r
-\r
- Set<NamedArea> namedAreas = new HashSet<NamedArea>();\r
- namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));\r
- //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));\r
- //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));\r
-\r
- Classification taxonmicTree = classificationDao.findByUuid(classificationUuid);\r
-\r
- // prepare some synonym relation ships for some tests\r
- Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz);\r
- Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera);\r
- taxonRethera.addSynonym(synAtroposAgassiz, SynonymRelationshipType.SYNONYM_OF());\r
- logger.warn("addSynonym(..)");\r
- //this.taxonDao.clear();\r
- Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);\r
- Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);\r
- taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymRelationshipType.SYNONYM_OF());\r
- this.taxonDao.save(taxonRetheraSecCdmtest);\r
- //this.taxonDao.clear();\r
- Taxon test = (Taxon)this.taxonDao.findByUuid(retheraSecCdmtest);\r
- Set<Synonym> synonyms = test.getSynonyms();\r
- // 1. searching for a taxon (Rethera)\r
- //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);\r
-\r
- List<TaxonBase> results = taxonDao.getTaxaByName(true,false, false, "Rethera", null, MatchMode.BEGINNING, namedAreas,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);\r
-\r
- // 2. searching for a taxon (Rethera) contained in a specific classification\r
- results = taxonDao.getTaxaByName(true, false, false, "Rethera", taxonmicTree, MatchMode.BEGINNING, namedAreas,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);\r
-\r
-\r
- // 3. searching for Synonyms\r
- results = taxonDao.getTaxaByName(false, true, false, "Atropo", null, MatchMode.ANYWHERE, null,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- /*System.err.println(results.get(0).getTitleCache() + " - " +results.get(1).getTitleCache() + " - " +results.get(2).getTitleCache() );\r
-\r
-\r
- System.err.println(((Synonym)results.get(0)).getAcceptedTaxa().contains(taxonRethera)+ " - " +((Synonym)results.get(1)).getAcceptedTaxa().contains(taxonRethera)+ " - " +((Synonym)results.get(2)).getAcceptedTaxa().contains(taxonRethera)+ " - " );\r
- */\r
- assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);\r
-\r
- // 4. searching for Synonyms\r
- results = taxonDao.getTaxaByName(false, true, false, "Atropo", null, MatchMode.BEGINNING, null,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);\r
-\r
-\r
- // 5. searching for a Synonyms and Taxa\r
- // create a synonym relationship first\r
- results = taxonDao.getTaxaByName(true, true, false, "A", null, MatchMode.BEGINNING, namedAreas,\r
- null, null, null);\r
- //only five taxa have a distribution\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find 7 taxa but found "+results.size(), results.size() == 8);\r
- }\r
-\r
-\r
- /**\r
- * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Class<? extends TaxonBase>clazz, String queryString, Classification classification, MatchMode matchMode, Set<NamedArea> namedAreas, Integer pageNumber, Integer pageSize, List<String> propertyPaths)}\r
- * restricting the search by a set of Areas.\r
- */\r
- @Test\r
- @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public void testFindByNameTitleCache() {\r
-\r
- Set<NamedArea> namedAreas = new HashSet<NamedArea>();\r
- namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));\r
- //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));\r
- //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));\r
-\r
- Classification classification = classificationDao.findByUuid(classificationUuid);\r
-\r
- // prepare some synonym relation ships for some tests\r
- Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz);\r
- Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera);\r
- taxonRethera.addSynonym(synAtroposAgassiz, SynonymRelationshipType.SYNONYM_OF());\r
- logger.warn("addSynonym(..)");\r
- this.taxonDao.clear();\r
- Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);\r
- Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);\r
- taxonRetheraSecCdmtest.addSynonym(synAtroposLeach, SynonymRelationshipType.SYNONYM_OF());\r
- this.taxonDao.clear();\r
- // 1. searching for a taxon (Rethera)\r
- //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);\r
-\r
- List<TaxonBase> results = taxonDao.findByNameTitleCache(true, false, "Rethera Rothschild & Jordan, 1903", null, MatchMode.EXACT, namedAreas,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);\r
-\r
- // 2. searching for a taxon (Rethera) contained in a specific classification\r
- results = taxonDao.findByNameTitleCache(true, false, "Rethera Rothschild & Jordan, 1903", classification, MatchMode.EXACT, namedAreas,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1);\r
-\r
-\r
- // 3. searching for Synonyms\r
- results = taxonDao.findByNameTitleCache(false, true, "Atropo", null, MatchMode.ANYWHERE, null,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
-\r
- assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);\r
-\r
- // 4. searching for Synonyms\r
- results = taxonDao.findByNameTitleCache(false, true, "Atropo", null, MatchMode.BEGINNING, null,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2);\r
-\r
-\r
- // 5. searching for a Synonyms and Taxa\r
- // create a synonym relationship first\r
- Synonym syn = (Synonym)taxonDao.findByUuid(this.atroposLeach);\r
- Taxon tax = (Taxon) taxonDao.findByUuid(rethera);\r
- tax.addSynonym(syn, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
-\r
- taxonDao.save(tax);\r
- results = taxonDao.findByNameTitleCache(true, true, "A", null, MatchMode.BEGINNING, namedAreas,\r
- null, null, null);\r
- assertNotNull("getTaxaByName should return a List", results);\r
- assertTrue("expected to find 8 taxa but found "+results.size(), results.size() == 8);\r
- }\r
-\r
- @Test\r
- @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public void testTaxonNameInTwoClassifications(){\r
- int numberOfClassifications = classificationDao.count();\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("taxonNodes");\r
- List<TaxonBase> taxa = taxonDao.getTaxaByName(true, true, false, "P*", null, MatchMode.BEGINNING, null, null, null, null);\r
- Taxon taxon = (Taxon)taxa.get(0);\r
- Set<TaxonNode> nodes = taxon.getTaxonNodes();\r
- assertTrue(nodes.size() == 1);\r
- //assertNotNull(taxa);\r
- //assertTrue(taxa.size() > 0);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testFindByUuid() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(uuid);\r
- assertNotNull("findByUuid should return a taxon",taxon);\r
- assertFalse("findByUuid should not return a taxon with it's name initialized",Hibernate.isInitialized(taxon.getName()));\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testLoad() {\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("name");\r
- propertyPaths.add("sec");\r
- Taxon taxon = (Taxon)taxonDao.load(uuid, propertyPaths);\r
- assertNotNull("findByUuid should return a taxon",taxon);\r
- assertTrue("load should return a taxon with it's name initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getName()));\r
- assertTrue("load should return a taxon with it's secundum reference initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getSec()));\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testCountTaxonRelationships() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon must exist";\r
-\r
- int numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo);\r
- assertEquals("countTaxonRelationships should return 23", 23, numberOfRelatedTaxa);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testCountTaxaByName() {\r
- long numberOfTaxa = taxonDao.countTaxaByName(true, false, false, "A*", null, MatchMode.BEGINNING, null);\r
- assertEquals(numberOfTaxa, 9);\r
- numberOfTaxa = taxonDao.countTaxaByName(true, false, false, "Aus aus", null, MatchMode.EXACT, null);\r
- assertEquals(numberOfTaxa, 1);\r
- numberOfTaxa = taxonDao.countTaxaByName(false, true, false, "A*", null, MatchMode.BEGINNING, null);\r
- assertEquals(numberOfTaxa, 3);\r
- numberOfTaxa = taxonDao.countTaxaByName(true, true, false, "A*", null, MatchMode.BEGINNING, null);\r
- assertEquals(numberOfTaxa,12);\r
- numberOfTaxa = taxonDao.countTaxaByName(true, true, false, "Aasfwerfwf fffe", null, MatchMode.BEGINNING, null);\r
- assertEquals(numberOfTaxa, 0);\r
-// FIXME implement test for search in specific classification\r
-// Reference reference = referenceDao.findByUuid(UUID.fromString("596b1325-be50-4b0a-9aa2-3ecd610215f2"));\r
-// numberOfTaxa = taxonDao.countTaxaByName("A*", MatchMode.BEGINNING, SelectMode.ALL, null, null);\r
-// assertEquals(numberOfTaxa, 2);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testRelatedTaxa() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon must exist";\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("fromTaxon");\r
- propertyPaths.add("fromTaxon.name");\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new OrderHint("relatedFrom.name.genusOrUninomial", SortOrder.ASCENDING));\r
- orderHints.add(new OrderHint("relatedFrom.name.specificEpithet", SortOrder.ASCENDING));\r
- orderHints.add(new OrderHint("relatedFrom.name.infraSpecificEpithet", SortOrder.ASCENDING));\r
-\r
- List<TaxonRelationship> relatedTaxa = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);\r
- assertNotNull("getRelatedTaxa should return a List",relatedTaxa);\r
- assertEquals("getRelatedTaxa should return all 23 related taxa",relatedTaxa.size(),23);\r
- assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon()));\r
- assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon().getName()));\r
-\r
- assertEquals("Acherontia should appear first in the list of related taxa", relatedTaxa.get(0).getFromTaxon().getTitleCache(), "Acherontia Laspeyres, 1809 sec. cate-sphingidae.org");\r
- assertEquals("Sphingonaepiopsis should appear last in the list of related taxa", relatedTaxa.get(22).getFromTaxon().getTitleCache(), "Sphinx Linnaeus, 1758 sec. cate-sphingidae.org");\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGetRelatedTaxaPaged() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon must exist";\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("fromTaxon");\r
- propertyPaths.add("fromTaxon.name");\r
-\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));\r
-\r
- List<TaxonRelationship> firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);\r
- List<TaxonRelationship> secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),10, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);\r
- List<TaxonRelationship> thirdPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 2, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);\r
-\r
- assertNotNull("getRelatedTaxa: 10, 0 should return a List",firstPage);\r
- assertEquals("getRelatedTaxa: 10, 0 should return a List with 10 elements",10,firstPage.size());\r
- assertNotNull("getRelatedTaxa: 10, 1 should return a List",secondPage);\r
- assertEquals("getRelatedTaxa: 10, 1 should return a List with 10 elements",secondPage.size(),10);\r
- assertNotNull("getRelatedTaxa: 10, 2 should return a List",thirdPage);\r
- assertEquals("getRelatedTaxa: 10, 2 should return a List with 3 elements",thirdPage.size(),3);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testCountSynonymRelationships() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
-\r
- int numberOfSynonymRelationships = taxonDao.countSynonyms(taxon,null);\r
- assertEquals("countSynonymRelationships should return 5",5,numberOfSynonymRelationships);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testSynonymRelationships() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("synonym");\r
- propertyPaths.add("synonym.name");\r
-\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));\r
-\r
- List<SynonymRelationship> synonyms = taxonDao.getSynonyms(taxon, null, null, null,orderHints,propertyPaths);\r
-\r
- assertNotNull("getSynonyms should return a List",synonyms);\r
- assertEquals("getSynonyms should return 5 SynonymRelationship entities",synonyms.size(),5);\r
- assertTrue("getSynonyms should return SynonymRelationship objects with the synonym initialized",Hibernate.isInitialized(synonyms.get(0).getSynonym()));\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testCountSynonymRelationshipsByType() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
-\r
- int numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());\r
- assertEquals("countSynonyms should return 4",numberOfTaxonomicSynonyms, 4);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testSynonymRelationshipsByType() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
-\r
- List<SynonymRelationship> synonyms = taxonDao.getSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), null, null,null,null);\r
-\r
- assertNotNull("getSynonyms should return a List",synonyms);\r
- assertEquals("getSynonyms should return 4 SynonymRelationship entities",synonyms.size(),4);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testPageSynonymRelationships(){\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
-\r
- List<SynonymRelationship> firstPage = taxonDao.getSynonyms(taxon, null, 4, 0,null,null);\r
- List<SynonymRelationship> secondPage = taxonDao.getSynonyms(taxon, null, 4, 1,null,null);\r
-\r
- assertNotNull("getSynonyms: 4, 0 should return a List",firstPage);\r
- assertEquals("getSynonyms: 4, 0 should return 4 SynonymRelationships", firstPage.size(),4);\r
- assertNotNull("getSynonyms: 4, 1 should return a List",secondPage);\r
- assertEquals("getSynonyms: 4, 1 should return 1 SynonymRelationship",secondPage.size(),1);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGetTaxonMatchingUninomial() {\r
- List<TaxonBase> result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", "*", "*", "*",null,null,null);\r
-\r
- assertNotNull("findTaxaByName should return a List", result);\r
- assertEquals("findTaxaByName should return two Taxa",2,result.size());\r
- assertEquals("findTaxaByName should return a Taxon with id 5",5,result.get(0).getId());\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGetTaxonMatchingSpeciesBinomial() {\r
- List<TaxonBase> result = taxonDao.findTaxaByName(Taxon.class,"Smerinthus", null, "kindermannii", null,null,null,null);\r
-\r
- assertNotNull("findTaxaByName should return a List", result);\r
- assertEquals("findTaxaByName should return one Taxon",1,result.size());\r
- assertEquals("findTaxaByName should return a Taxon with id 8",8,result.get(0).getId());\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGetTaxonMatchingTrinomial() {\r
- List<TaxonBase> result = taxonDao.findTaxaByName(Taxon.class,"Cryptocoryne", null,"purpurea","borneoensis",null,null,null);\r
-\r
- assertNotNull("findTaxaByName should return a List", result);\r
- assertEquals("findTaxaByName should return one Taxon",1,result.size());\r
- assertEquals("findTaxaByName should return a Taxon with id 38",38,result.get(0).getId());\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testNegativeMatch() {\r
- List<TaxonBase> result = taxonDao.findTaxaByName(Taxon.class,"Acherontia", null,"atropos","dehli",null,null,null);\r
-\r
- assertNotNull("findTaxaByName should return a List", result);\r
- assertTrue("findTaxaByName should return an empty List",result.isEmpty());\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testCountAllTaxa() {\r
- int numberOfTaxa = taxonDao.count(Taxon.class);\r
- assertEquals("count should return 33 taxa",33, numberOfTaxa);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testListAllTaxa() {\r
- List<TaxonBase> taxa = taxonDao.list(Taxon.class,100, 0);\r
- assertNotNull("list should return a List",taxa);\r
- assertEquals("list should return 33 taxa",33, taxa.size());\r
- }\r
-\r
- @Test\r
- @DataSet\r
- // @ExpectedDataSet\r
- public void testDelete() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon != null : "taxon must exist";\r
- taxonDao.delete(taxon);\r
- taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon == null : "taxon must not exist";\r
- setComplete();\r
- endTransaction();\r
- try {\r
- printDataSet(new FileOutputStream("test.xml"), TABLE_NAMES);\r
- } catch (FileNotFoundException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet\r
- // @ExpectedDataSet("TaxonDaoHibernateImplTest.testDelete-result.xml")\r
- public void testDeleteWithMarker() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- taxon.addMarker(Marker.NewInstance(MarkerType.IS_DOUBTFUL(), true));\r
- taxonDao.save(taxon);\r
- assert taxon != null : "taxon must exist";\r
-\r
- taxonDao.delete(taxon);\r
- commitAndStartNewTransaction(null);\r
- taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assert taxon == null : "taxon must not exist";\r
- setComplete();\r
- endTransaction();\r
- try {\r
- printDataSet(new FileOutputStream("test.xml"), TABLE_NAMES);\r
- } catch (FileNotFoundException e) {\r
- e.printStackTrace();\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testDeleteWithChildren() {\r
- Taxon taxonWithChildren = (Taxon)taxonDao.findByUuid(mimas);\r
- assert taxonWithChildren != null : "taxon must exist";\r
- assertEquals(taxonWithChildren.getTaxonomicChildrenCount(), 2);\r
- Taxon parent = (Taxon)taxonDao.findByUuid(sphingidae);\r
- assertSame(taxonWithChildren.getTaxonomicParent(), parent);\r
- assertEquals(parent.getTaxonomicChildrenCount(), 204);\r
- taxonDao.delete(taxonWithChildren);\r
- assertEquals(parent.getTaxonomicChildrenCount(), 203);\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testFindDeleted() {\r
- TaxonBase<?> taxon = taxonDao.findByUuid(acherontia);\r
- assertNull("findByUuid should return null in this view", taxon);\r
- assertFalse("exist should return false in this view",taxonDao.exists(acherontia));\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testFindDeletedInPreviousView() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);\r
- assertNotNull("findByUuid should return a taxon in this view",taxon);\r
- assertTrue("exists should return true in this view", taxonDao.exists(acherontia));\r
-\r
- try{\r
- assertEquals("There should be 3 relations to this taxon in this view",3,taxon.getRelationsToThisTaxon().size());\r
- } catch(Exception e) {\r
- fail("We should not experience any problems initializing proxies with envers");\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testGetAuditEvents() {\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("name");\r
- propertyPaths.add("createdBy");\r
- propertyPaths.add("updatedBy");\r
-\r
- List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(taxon, null,null,null,propertyPaths);\r
- assertNotNull("getAuditEvents should return a list",auditEvents);\r
- assertFalse("the list should not be empty",auditEvents.isEmpty());\r
- assertEquals("There should be two AuditEventRecords in the list",2, auditEvents.size());\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testGetAuditEventsFromNow() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(taxon, null,null,AuditEventSort.FORWARDS,null);\r
- assertNotNull("getAuditEvents should return a list",auditEvents);\r
- assertFalse("the list should not be empty",auditEvents.isEmpty());\r
- assertEquals("There should be one audit event in the list",1,auditEvents.size());\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testCountAuditEvents() {\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- int numberOfAuditEvents = taxonDao.countAuditEvents(taxon,null);\r
- assertEquals("countAuditEvents should return 2",numberOfAuditEvents,2);\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void getPreviousAuditEvent() {\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- AuditEventRecord<TaxonBase> auditEvent = taxonDao.getPreviousAuditEvent(taxon);\r
- assertNotNull("getPreviousAuditEvent should not return null as there is at least one audit event prior to the current one",auditEvent);\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void getPreviousAuditEventAtBeginning() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- TaxonBase taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- AuditEventRecord<TaxonBase> auditEvent = taxonDao.getPreviousAuditEvent(taxon);\r
- assertNull("getPreviousAuditEvent should return null if we're at the first audit event anyway",auditEvent);\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void getNextAuditEvent() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- AuditEventRecord<TaxonBase> auditEvent = taxonDao.getNextAuditEvent(taxon);\r
- assertNotNull("getNextAuditEvent should not return null as there is at least one audit event after the current one",auditEvent);\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void getNextAuditEventAtEnd() {\r
- AuditEventContextHolder.getContext().setAuditEvent(mostRecentAuditEvent);\r
- TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- AuditEventRecord<TaxonBase> auditEvent = taxonDao.getNextAuditEvent(taxon);\r
- assertNull("getNextAuditEvent should return null as there no more audit events after the current one",auditEvent);\r
- }\r
-\r
- @Test\r
- @DataSet\r
- @ExpectedDataSet\r
- @Ignore\r
- public void testAddChild() throws Exception {\r
- Taxon parent = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert parent != null : "taxon cannot be null";\r
- Taxon child = Taxon.NewInstance(null, null);\r
- child.setTitleCache("Acherontia lachesis diehli Eitschberger, 2003", true);\r
- child.addTaxonRelation(parent, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),null, null);\r
- taxonDao.save(child);\r
- setComplete();\r
- endTransaction();\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testFind() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- assertEquals("getTaxonomicChildrenCount should return 1 in this view",1,taxon.getTaxonomicChildrenCount());\r
- assertEquals("getRelationsToThisTaxon should contain 1 TaxonRelationship in this view",1,taxon.getRelationsToThisTaxon().size());\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testFindInPreviousView() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- assertEquals("getTaxonomicChildrenCount should return 0 in this view",0,taxon.getTaxonomicChildrenCount());\r
- assertTrue("getRelationsToThisTaxon should contain 0 TaxonRelationship in this view",taxon.getRelationsToThisTaxon().isEmpty());\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testGetRelations() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("fromTaxon");\r
- propertyPaths.add("fromTaxon.name");\r
-\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));\r
-\r
- List<TaxonRelationship> taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom);\r
- assertNotNull("getRelatedTaxa should return a list", taxonRelations);\r
- assertEquals("there should be one TaxonRelationship in the list in the current view",1,taxonRelations.size());\r
- assertTrue("TaxonRelationship.relatedFrom should be initialized",Hibernate.isInitialized(taxonRelations.get(0).getFromTaxon()));\r
- assertTrue("TaxonRelationship.relatedFrom.name should be initialized",Hibernate.isInitialized(taxonRelations.get(0).getFromTaxon().getName()));\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testCountRelations() {\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
- assertEquals("countRelatedTaxa should return 1 in the current view",1, taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo));\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testGetRelationsInPreviousView() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("relatedFrom");\r
- propertyPaths.add("relatedFrom.name");\r
-\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));\r
-\r
- List<TaxonRelationship> taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom);\r
- assertNotNull("getRelatedTaxa should return a list",taxonRelations);\r
- assertTrue("there should be no TaxonRelationships in the list in the prior view",taxonRelations.isEmpty());\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFind.xml")\r
- public void testCountRelationsInPreviousView() {\r
- AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);\r
- Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);\r
- assert taxon != null : "taxon cannot be null";\r
- assertEquals("countRelatedTaxa should return 0 in the current view",0, taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), TaxonRelationship.Direction.relatedTo));\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGroupTaxa() {\r
- List<Grouping> groups = new ArrayList<Grouping>();\r
- groups.add(new GroupByCount("count",SortOrder.DESCENDING));\r
- groups.add(new Grouping("name.genusOrUninomial", "genus", "n", SortOrder.ASCENDING));\r
- List<Object[]> results = taxonDao.group(null, null, null, groups,null);\r
- System.out.println("count\tname.genuOrUninomial");\r
- for(Object[] result : results) {\r
- System.out.println(result[0] + "\t" + result[1]);\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGroupTaxaByClass() {\r
- List<Grouping> groups = new ArrayList<Grouping>();\r
- groups.add(new GroupByCount("count",SortOrder.DESCENDING));\r
- groups.add(new Grouping("class", "class",null, SortOrder.ASCENDING));\r
- List<Object[]> results = taxonDao.group(null, null, null, groups,null);\r
- System.out.println("count\tclass");\r
- for(Object[] result : results) {\r
- System.out.println(result[0] + "\t" + result[1]);\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testNativeSQLOrder() {\r
- List<OrderHint> orderHints = new ArrayList<OrderHint>();\r
- orderHints.add(new NativeSqlOrderHint("case when {alias}.titleCache like 'C%' then 0 else 1 end",SortOrder.ASCENDING));\r
-\r
- List<TaxonBase> results = taxonDao.list(null, null, orderHints);\r
- System.out.println("native SQL order");\r
- for(TaxonBase<?> result : results) {\r
- System.out.println(result.getTitleCache());\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet\r
- public void testGroupByDateTaxa() {\r
- List<Grouping> groups = new ArrayList<Grouping>();\r
- groups.add(new GroupByCount("count",null));\r
- groups.add(new GroupByDate("created", "dateGroup", SortOrder.ASCENDING, GroupByDate.Resolution.MONTH));\r
- List<Object[]> results = taxonDao.group(null, null, null, groups,null);\r
- System.out.println("count\tyear\tmonth");\r
- for(Object[] result : results) {\r
- System.out.println(result[0] + "\t" + result[1] + "\t" + result[2]);\r
- }\r
- }\r
-\r
- @Test\r
- @DataSet ("TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public final void testGetTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(){\r
- Classification classification = classificationDao.findByUuid(classificationUuid);\r
- assertNotNull(taxonDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification));\r
- }\r
-\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- @Ignore\r
- public void testGetAuditEventsByType() {\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("name");\r
- propertyPaths.add("createdBy");\r
- propertyPaths.add("updatedBy");\r
- int count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null);\r
- List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, null,null, null, AuditEventSort.FORWARDS, propertyPaths);\r
- assertNotNull("getAuditEvents should return a list",auditEvents);\r
- assertFalse("the list should not be empty",auditEvents.isEmpty());\r
- assertEquals("There should be thirty eight AuditEventRecords in the list",38, auditEvents.size());\r
- }\r
-\r
- @Test\r
- @Ignore\r
- @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")\r
- public void testGetAuditEventsByTypeWithRestrictions() {\r
-\r
- List<String> propertyPaths = new ArrayList<String>();\r
- propertyPaths.add("name");\r
- propertyPaths.add("createdBy");\r
- propertyPaths.add("updatedBy");\r
-\r
- List<AuditCriterion> criteria = new ArrayList<AuditCriterion>();\r
- criteria.add(AuditEntity.property("lsid_lsid").isNotNull());\r
-\r
- List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, criteria,null, null, AuditEventSort.FORWARDS, propertyPaths);\r
- assertNotNull("getAuditEvents should return a list",auditEvents);\r
- assertFalse("the list should not be empty",auditEvents.isEmpty());\r
- assertEquals("There should be one AuditEventRecord in the list",1, auditEvents.size());\r
- }\r
- @Test\r
- @DataSet("TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")\r
- public void testGetCommonName(){\r
-\r
-\r
- List<Object[]> commonNameResults = taxonDao.getTaxaByCommonName("common%", null,\r
- MatchMode.BEGINNING, null, null, null, null);\r
-\r
- assertNotNull("getTaxaByCommonName should return a list", commonNameResults);\r
- assertFalse("the list should not be empty", commonNameResults.isEmpty());\r
- assertEquals("There should be one Taxon with common name", 1,commonNameResults.size());\r
- assertEquals(" sec. ???", ((TaxonBase)commonNameResults.get(0)[0]).getTitleCache());\r
-\r
- }\r
-\r
-\r
-// @Test\r
-// public void testDeploy(){\r
-// TaxonBase taxonBase = taxonDao.findByUuid(UUID.fromString("6bfedf25-6dbc-4d5c-9d56-84f9052f3b2a"));\r
-//\r
-// Synonym synonym = taxonBase.deproxy(taxonBase, Synonym.class);\r
-// }\r
-\r
-\r
-\r
-}\r
+/**
+* Copyright (C) 2009 EDIT
+* 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.persistence.dao.hibernate.taxon;
+
+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.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import org.hibernate.Hibernate;
+import org.hibernate.envers.query.AuditEntity;
+import org.hibernate.envers.query.criteria.AuditCriterion;
+import org.hibernate.proxy.HibernateProxy;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.unitils.dbunit.annotation.DataSet;
+import org.unitils.dbunit.annotation.ExpectedDataSet;
+import org.unitils.spring.annotation.SpringBeanByType;
+
+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.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.SynonymType;
+import eu.etaxonomy.cdm.model.taxon.Taxon;
+import eu.etaxonomy.cdm.model.taxon.TaxonBase;
+import eu.etaxonomy.cdm.model.taxon.TaxonNode;
+import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
+import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
+import eu.etaxonomy.cdm.model.view.AuditEvent;
+import eu.etaxonomy.cdm.model.view.AuditEventRecord;
+import eu.etaxonomy.cdm.model.view.context.AuditEventContextHolder;
+import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+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.query.GroupByCount;
+import eu.etaxonomy.cdm.persistence.query.GroupByDate;
+import eu.etaxonomy.cdm.persistence.query.Grouping;
+import eu.etaxonomy.cdm.persistence.query.MatchMode;
+import eu.etaxonomy.cdm.persistence.query.NativeSqlOrderHint;
+import eu.etaxonomy.cdm.persistence.query.OrderHint;
+import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
+import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
+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;
+
+ @SpringBeanByType
+ private IReferenceDao referenceDao;
+
+ @SpringBeanByType
+ 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 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", "TAXONBASE", "TAXONBASE_AUD"
+ , "TAXONNAME", "TAXONNAME_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" };
+
+
+ @Before
+ public void setUp() {
+
+
+ previousAuditEvent = new AuditEvent();
+ previousAuditEvent.setRevisionNumber(1025);
+ previousAuditEvent.setUuid(UUID.fromString("a680fab4-365e-4765-b49e-768f2ee30cda"));
+ mostRecentAuditEvent = new AuditEvent();
+ mostRecentAuditEvent.setRevisionNumber(1026);
+ mostRecentAuditEvent.setUuid(UUID.fromString("afe8e761-8545-497b-9134-6a6791fc0b0d"));
+ AuditEventContextHolder.clearContext(); // By default we're in the current view (i.e. view == null)
+
+ northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f");
+ southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea");
+
+ classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9");
+ includeUnpublished = true;
+ }
+
+ @After
+ public void tearDown() {
+ AuditEventContextHolder.clearContext();
+ }
+
+ /**
+ * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#TaxonDaoHibernateImpl()}.
+ */
+ @Test
+ @DataSet
+ public void testInit() {
+ logger.warn("testInit()");
+ assertNotNull("Instance of ITaxonDao expected",taxonDao);
+ assertNotNull("Instance of IReferenceDao expected",referenceDao);
+ }
+
+ @Test
+ @DataSet
+ public void testGetTaxaByName() {
+
+ includeUnpublished= true;
+ boolean accepted = true;
+
+ Reference sec = referenceDao.findById(1);
+ assert sec != null : "sec must exist";
+
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> results = taxonDao.getTaxaByName("Aus", includeUnpublished, sec);
+ assertNotNull("getTaxaByName should return a List", results);
+ //assertFalse("The list should not be empty", results.isEmpty());
+ assertEquals(1, results.size());
+
+ results = taxonDao.getTaxaByName("A*", MatchMode.BEGINNING, accepted, includeUnpublished, null, null);
+ assertNotNull("getTaxaByName should return a List", results);
+
+ int numberOfTaxaByName_A = 5;
+
+ //logger.setLevel(Level.DEBUG); //FIXME #######################
+ if (logger.isDebugEnabled()) {
+ for (int i = 0; i < results.size(); i++) {
+ String nameCache = "";
+ 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());
+ }
+ }
+
+ 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());
+
+// assertEquals(results.get(0).getTitleCache(), "Abies sec. ???");
+// assertEquals(results.get(1).getTitleCache(), "Abies Mill.");
+// assertEquals(results.get(2).getTitleCache(), "Abies mill. sec. ???");
+// assertEquals(results.get(3).getTitleCache(), "Abies alba sec. ???");
+// assertEquals(results.get(4).getTitleCache(), "Abies alba Michx. sec. ???");
+// assertEquals(results.get(5).getTitleCache(), "Abies alba Mill. sec. ???");
+
+ 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, accepted, includeUnpublished, null, null);
+ assertNotNull("getTaxaByName should return a List", results);
+ assertEquals("Results list should contain one entity",1,results.size());
+ }
+
+
+ @Test
+ @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")
+ 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 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"
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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(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 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(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(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(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(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(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<TaxonBase> 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<NamedArea> 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)}.
+ */
+ @Test
+ @DataSet
+ public void testGetTaxaByNameForEditor() {
+ TaxonNode subtree = null;
+ Reference sec = referenceDao.findById(1);
+ assert sec != null : "sec must exist";
+
+ @SuppressWarnings("rawtypes")
+ List<UuidAndTitleCache<? extends IdentifiableEntity>> 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());
+ assertEquals(4, results.size());
+
+
+ results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "A",null, subtree, MatchMode.BEGINNING, null, null);
+ assertNotNull("getTaxaByName should return a List", results);
+ assertEquals(7, results.size());
+
+
+ results = taxonDao.getTaxaByNameForEditor(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null);
+ assertNotNull("getTaxaByName should return a List", results);
+ assertEquals(5, results.size());
+ assertEquals(results.get(0).getType(), Taxon.class);
+
+ results = taxonDao.getTaxaByNameForEditor(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null);
+ assertNotNull("getTaxaByName should return a List", results);
+ assertEquals(2, results.size());
+ assertEquals(results.get(0).getType(), Synonym.class);
+
+ 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(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", 8, results.size());
+
+ //TODO: test the search for misapplied names
+
+ }
+
+
+ /**
+ * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}
+ * restricting the search by a set of Areas.
+ */
+ @Test
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")
+ public void testGetTaxaByNameAndArea() {
+ TaxonNode subtree = null;
+ Set<NamedArea> namedAreas = new HashSet<>();
+ namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));
+ //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));
+ //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));
+
+ 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, SynonymType.SYNONYM_OF());
+// logger.warn("addSynonym(..)");
+
+ Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);
+ Taxon taxonRetheraSecCdmTest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);
+ taxonRetheraSecCdmTest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF());
+ this.taxonDao.save(taxonRetheraSecCdmTest);
+
+ Taxon test = (Taxon)this.taxonDao.findByUuid(retheraSecCdmtest);
+// Set<Synonym> synonyms3 = test.getSynonyms();
+ // 1. searching for a taxon (Rethera)
+ //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas);
+
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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(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(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() );
+
+
+ System.err.println(((Synonym)results.get(0)).getAcceptedTaxa().contains(taxonRethera)+ " - " +((Synonym)results.get(1)).getAcceptedTaxa().contains(taxonRethera)+ " - " +((Synonym)results.get(2)).getAcceptedTaxa().contains(taxonRethera)+ " - " );
+ */
+ assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3);
+
+ // 4. searching for Synonyms
+ 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
+ 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 8 taxa but found "+results.size(), results.size() == 8);
+ }
+
+
+ /**
+ * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Class<? extends TaxonBase>clazz, String queryString, Classification classification, TaxonNode subtree, MatchMode matchMode, Set<NamedArea> namedAreas, Integer pageNumber, Integer pageSize, List<String> 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<NamedArea> namedAreas = new HashSet<>();
+ namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid));
+ //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid));
+ //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid));
+
+ 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, SynonymType.SYNONYM_OF());
+ //logger.warn("addSynonym(..)");
+ this.taxonDao.clear();
+ Synonym synAtroposLeach = (Synonym)taxonDao.findByUuid(atroposLeach);
+ Taxon taxonRetheraSecCdmtest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest);
+ 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);
+
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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(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(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(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
+ // attache a synonym first
+ Synonym syn = (Synonym)taxonDao.findByUuid(this.atroposLeach);
+ Taxon tax = (Taxon) taxonDao.findByUuid(rethera);
+ tax.addSynonym(syn, SynonymType.HETEROTYPIC_SYNONYM_OF());
+
+ taxonDao.save(tax);
+ 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);
+ }
+
+ @Test
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")
+ public void testTaxonNameInTwoClassifications(){
+ TaxonNode subtree = null;
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("taxonNodes");
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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<TaxonNode> nodes = taxon.getTaxonNodes();
+ assertTrue(nodes.size() == 1);
+ //assertNotNull(taxa);
+ //assertTrue(taxa.size() > 0);
+ }
+
+ @Test
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")
+ public void testGetTaxaByNameProParteSynonym(){
+ TaxonNode subtree = null;
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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);
+ assertFalse("findByUuid should not return a taxon with it's name initialized",Hibernate.isInitialized(taxon.getName()));
+ }
+
+ @Test
+ @DataSet
+ public void testLoad() {
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("name");
+ propertyPaths.add("sec");
+ Taxon taxon = (Taxon)taxonDao.load(uuid, propertyPaths);
+ assertNotNull("findByUuid should return a taxon",taxon);
+ assertTrue("load should return a taxon with it's name initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getName()));
+ assertTrue("load should return a taxon with it's secundum reference initialized, given that the property was specified in the method",Hibernate.isInitialized(taxon.getSec()));
+ }
+
+ @Test
+ @DataSet
+ public void testCountTaxonRelationshipsByTaxon() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon must exist";
+
+ 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() {
+ 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
+ @DataSet
+ public void testRelatedTaxa() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon must exist";
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("fromTaxon");
+ propertyPaths.add("fromTaxon.name");
+ List<OrderHint> 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));
+
+ long count = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
+ includeUnpublished, TaxonRelationship.Direction.relatedTo);
+ assertEquals("Count should return 8 (related taxa)", 8, count);
+
+ List<TaxonRelationship> 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 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", "Sphingonaepiopsis Wallengren, 1858 sec. cate-sphingidae.org", relatedTaxa.get(relatedTaxa.size()-1).getFromTaxon().getTitleCache());
+ }
+
+ @Test
+ @DataSet
+ public void testGetRelatedTaxaPaged() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon must exist";
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("fromTaxon");
+ propertyPaths.add("fromTaxon.name");
+
+ List<OrderHint> orderHints = new ArrayList<>();
+ orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));
+
+ int pageSize = 3;
+ List<TaxonRelationship> firstPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
+ includeUnpublished, pageSize, 0, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);
+ List<TaxonRelationship> secondPage = taxonDao.getTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
+ includeUnpublished, pageSize, 1, orderHints,propertyPaths, TaxonRelationship.Direction.relatedTo);
+ List<TaxonRelationship> 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 testCountSynonyms() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+
+ long numberOfRelatedSynonym = taxonDao.countSynonyms(taxon,null);
+ assertEquals("countSynonyms should return 3", 3, numberOfRelatedSynonym);
+ }
+
+ @Test
+ @DataSet
+ public void testGetSynonyms() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+ List<String> propertyPaths = new ArrayList<String>();
+ propertyPaths.add("synonym");
+ propertyPaths.add("synonym.name");
+
+ List<OrderHint> orderHints = new ArrayList<>();
+ orderHints.add(new OrderHint("titleCache", SortOrder.ASCENDING));
+
+ List<Synonym> synonyms = taxonDao.getSynonyms(taxon, null, null, null,orderHints,propertyPaths);
+
+ 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 testCountSynonymsByType() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+
+ long numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF());
+ assertEquals("countSynonyms should return 4", 3, numberOfTaxonomicSynonyms);
+ }
+
+ @Test
+ @DataSet
+ public void testSynonymsByType() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+
+ List<Synonym> synonyms = taxonDao.getSynonyms(taxon, SynonymType.HETEROTYPIC_SYNONYM_OF(), null, null,null,null);
+
+ assertNotNull("getSynonyms should return a List", synonyms);
+ assertEquals("getSynonyms should return 4 Synonyms", 3, synonyms.size());
+ }
+
+ @Test
+ @DataSet
+ public void testPageSynonyms(){
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+
+ int pageSize = 2;
+ List<Synonym> firstPage = taxonDao.getSynonyms(taxon, null, pageSize, 0,null,null);
+ List<Synonym> secondPage = taxonDao.getSynonyms(taxon, null, pageSize, 1,null,null);
+
+ 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<TaxonRelationshipType> 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<TaxonRelationship> 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<TaxonRelationshipType> 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
+ @DataSet("TaxonNodeDaoHibernateImplTest.xml")
+ public void testListAcceptedTaxaFor() {
+ UUID acheontitia_ciprosus = UUID.fromString("3ef145f7-bd92-4a64-8afd-2b8203e00e02");
+
+ Synonym synonym = (Synonym)taxonDao.findByUuid(acheontitia_ciprosus);
+ assertNotNull("synonym must exist", synonym);
+
+ Taxon taxon = taxonDao.acceptedTaxonFor(synonym, null, null);
+ assertNotNull("listAcceptedTaxaFor should return a taxon", taxon);
+
+ Classification classification = classificationDao.load(classificationUuid);
+ assertNotNull("classification must exist", classification);
+
+ taxon = taxonDao.acceptedTaxonFor(synonym, classification, null);
+ assertNull("listAcceptedTaxaFor should return not taxon due to classification filter", taxon);
+ }
+
+
+ @Test
+ @DataSet
+ public void testGetTaxonMatchingUninomial() {
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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());
+ assertEquals("findTaxaByName should return a Taxon with id 5",5,result.get(0).getId());
+ }
+
+ @Test
+ @DataSet
+ public void testGetTaxonMatchingSpeciesBinomial() {
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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());
+ assertEquals("findTaxaByName should return a Taxon with id 8",8,result.get(0).getId());
+ }
+
+ @Test
+ @DataSet
+ public void testGetTaxonMatchingTrinomial() {
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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());
+ assertEquals("findTaxaByName should return a Taxon with id 38",38,result.get(0).getId());
+ }
+
+ @Test
+ @DataSet
+ public void testNegativeMatch() {
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> 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());
+ }
+
+ @Test
+ @DataSet
+ public void testCountAllTaxa() {
+ long numberOfTaxa = taxonDao.count(Taxon.class);
+ assertEquals("count should return 14 taxa", 14, numberOfTaxa);
+ }
+
+ @Test
+ @DataSet
+ public void testListAllTaxa() {
+ List<Taxon> taxa = taxonDao.list(Taxon.class,100, 0);
+ assertNotNull("list should return a List", taxa);
+ assertEquals("list should return 14 taxa", 14, taxa.size());
+ }
+
+ @Test
+ @DataSet
+ // @ExpectedDataSet
+ public void testDelete() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon != null : "taxon must exist";
+ taxonDao.delete(taxon);
+ taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon == null : "taxon must not exist";
+ setComplete();
+ endTransaction();
+// try {
+// printDataSet(new FileOutputStream("test.xml"), TABLE_NAMES);
+// } catch (FileNotFoundException e) {
+// e.printStackTrace();
+// }
+ }
+
+ @Test
+ @DataSet
+ @ExpectedDataSet("TaxonDaoHibernateImplTest.testDelete-result.xml")
+ public void testDeleteWithMarker() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ taxon.addMarker(Marker.NewInstance(MarkerType.IS_DOUBTFUL(), true));
+ taxonDao.save(taxon);
+ assert taxon != null : "taxon must exist";
+
+ taxonDao.delete(taxon);
+ commitAndStartNewTransaction(null);
+ taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assert taxon == null : "taxon must not exist";
+ setComplete();
+ endTransaction();
+// try {
+// printDataSet(new FileOutputStream("test.xml"), TABLE_NAMES);
+// } catch (FileNotFoundException e) {
+// e.printStackTrace();
+// }
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void testFindDeleted() {
+ TaxonBase<?> taxon = taxonDao.findByUuid(acherontia);
+ assertNull("findByUuid should return null in this view", taxon);
+ assertFalse("exist should return false in this view",taxonDao.exists(acherontia));
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void testFindDeletedInPreviousView() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
+ assertNotNull("findByUuid should return a taxon in this view",taxon);
+ assertTrue("exists should return true in this view", taxonDao.exists(acherontia));
+
+ try{
+ assertEquals("There should be 3 relations to this taxon in this view",3,taxon.getRelationsToThisTaxon().size());
+ } catch(Exception e) {
+ fail("We should not experience any problems initializing proxies with envers");
+ }
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void testGetAuditEvents() {
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("name");
+ propertyPaths.add("createdBy");
+ propertyPaths.add("updatedBy");
+
+ @SuppressWarnings("rawtypes")
+ List<AuditEventRecord<TaxonBase>> auditEvents = taxonDao.getAuditEvents(taxon, null,null,null,propertyPaths);
+ assertNotNull("getAuditEvents should return a list",auditEvents);
+ assertFalse("the list should not be empty",auditEvents.isEmpty());
+ assertEquals("There should be two AuditEventRecords in the list",2, auditEvents.size());
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void testGetAuditEventsFromNow() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ @SuppressWarnings("rawtypes")
+ List<AuditEventRecord<TaxonBase>> 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());
+ assertEquals("There should be one audit event in the list",1,auditEvents.size());
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void testCountAuditEvents() {
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ long numberOfAuditEvents = taxonDao.countAuditEvents(taxon, null);
+ assertEquals("countAuditEvents should return 2",numberOfAuditEvents,2);
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void getPreviousAuditEvent() {
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ AuditEventRecord<TaxonBase> auditEvent = taxonDao.getPreviousAuditEvent(taxon);
+ assertNotNull("getPreviousAuditEvent should not return null as there is at least one audit event prior to the current one",auditEvent);
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void getPreviousAuditEventAtBeginning() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ @SuppressWarnings("rawtypes")
+ AuditEventRecord<TaxonBase> auditEvent = taxonDao.getPreviousAuditEvent(taxon);
+ assertNull("getPreviousAuditEvent should return null if we're at the first audit event anyway",auditEvent);
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void getNextAuditEvent() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ @SuppressWarnings("rawtypes")
+ AuditEventRecord<TaxonBase> auditEvent = taxonDao.getNextAuditEvent(taxon);
+ assertNotNull("getNextAuditEvent should not return null as there is at least one audit event after the current one",auditEvent);
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+ public void getNextAuditEventAtEnd() {
+ AuditEventContextHolder.getContext().setAuditEvent(mostRecentAuditEvent);
+ TaxonBase<?> taxon = taxonDao.findByUuid(sphingidae);
+ assert taxon != null : "taxon cannot be null";
+
+ @SuppressWarnings("rawtypes")
+ AuditEventRecord<TaxonBase> auditEvent = taxonDao.getNextAuditEvent(taxon);
+ assertNull("getNextAuditEvent should return null as there no more audit events after the current one",auditEvent);
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ public void testFind() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);
+ assert taxon != null : "taxon cannot be null";
+
+ assertEquals("getRelationsToThisTaxon should contain 1 TaxonRelationship in this view",1,taxon.getRelationsToThisTaxon().size());
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ public void testFindInPreviousView() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);
+ assert taxon != null : "taxon cannot be null";
+
+ assertTrue("getRelationsToThisTaxon should contain 0 TaxonRelationship in this view",taxon.getRelationsToThisTaxon().isEmpty());
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ public void testGetRelations() {
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);
+ assert taxon != null : "taxon cannot be null";
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("fromTaxon");
+ propertyPaths.add("fromTaxon.name");
+
+ List<OrderHint> orderHints = new ArrayList<>();
+ orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));
+
+ List<TaxonRelationship> 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()));
+ assertTrue("TaxonRelationship.relatedFrom.name should be initialized",Hibernate.isInitialized(taxonRelations.get(0).getFromTaxon().getName()));
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ 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(),
+ includeUnpublished, TaxonRelationship.Direction.relatedTo));
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ public void testGetRelationsInPreviousView() {
+ AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);
+ Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis);
+ assert taxon != null : "taxon cannot be null";
+
+ List<String> propertyPaths = new ArrayList<String>();
+ propertyPaths.add("relatedFrom");
+ propertyPaths.add("relatedFrom.name");
+
+ List<OrderHint> orderHints = new ArrayList<>();
+ orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING));
+
+ List<TaxonRelationship> 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());
+ }
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFind.xml")
+ public void testCountRelationsInPreviousView() {
+ 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(),
+ includeUnpublished, TaxonRelationship.Direction.relatedTo));
+ }
+
+ @Test
+ @DataSet
+ public void testGroupTaxa() {
+ List<Grouping> groups = new ArrayList<>();
+ groups.add(new GroupByCount("count",SortOrder.DESCENDING));
+ groups.add(new Grouping("name.genusOrUninomial", "genus", "n", SortOrder.ASCENDING));
+ List<Object[]> results = taxonDao.group(null, null, null, groups,null);
+ 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<Grouping> groups = new ArrayList<>();
+ groups.add(new GroupByCount("count",SortOrder.DESCENDING));
+ groups.add(new Grouping("class", "class",null, SortOrder.ASCENDING));
+ List<Object[]> results = taxonDao.group(null, null, null, groups,null);
+ 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<OrderHint> orderHints = new ArrayList<>();
+ orderHints.add(new NativeSqlOrderHint("case when {alias}.titleCache like 'C%' then 0 else 1 end",SortOrder.ASCENDING));
+
+ @SuppressWarnings("rawtypes")
+ List<TaxonBase> results = taxonDao.list(null, null, orderHints);
+ if(logger.isTraceEnabled()){
+ System.out.println("native SQL order");
+ for(TaxonBase<?> result : results) {
+ System.out.println(result.getTitleCache());
+ }
+ }
+ }
+
+ @Test
+ @DataSet
+ public void testGroupByDateTaxa() {
+ List<Grouping> groups = new ArrayList<>();
+ groups.add(new GroupByCount("count",null));
+ groups.add(new GroupByDate("created", "dateGroup", SortOrder.ASCENDING, GroupByDate.Resolution.MONTH));
+ List<Object[]> results = taxonDao.group(null, null, null, groups,null);
+ 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.testFindDeleted.xml")
+ //NOTE: There is a problem with loading AuditEvents if this test runs
+ //stand alone or as first (one of the first) in the test suite. For some reason
+ //the AuditEvent records from the @DataSet are not inserted into the database then,
+ //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 testGetAuditEventsByTypeWithRestrictions() {
+ commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"});
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("name");
+ propertyPaths.add("createdBy");
+ propertyPaths.add("updatedBy");
+
+ List<AuditCriterion> criteria = new ArrayList<>();
+ criteria.add(AuditEntity.property("lsid_lsid").isNotNull());
+
+ long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null);
+
+ @SuppressWarnings("rawtypes")
+ List<AuditEventRecord<TaxonBase>> 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());
+ assertEquals("There should be one AuditEventRecord in the list",1, auditEvents.size());
+ }
+
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml")
+// @DataSets({ //for testing only
+// @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml"),
+// @DataSet("TaxonDaoHibernateImplTest.testFindDeletedAuditEvents.xml")
+// })
+ //NOTE: There is a problem with loading AuditEvents if this test runs
+ //stand alone or as first (one of the first) in the test suite. For some reason
+ //the AuditEvent records from the @DataSet are not inserted into the database then,
+ //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"});
+ commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"});
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("name");
+ propertyPaths.add("createdBy");
+ propertyPaths.add("updatedBy");
+ long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null);
+ @SuppressWarnings("rawtypes")
+ List<AuditEventRecord<TaxonBase>> 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", 2, auditEvents.size());
+ }
+
+
+ @Test
+ @DataSet("TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml")
+ public void testGetCommonName(){
+ List<Taxon> commonNameResults = taxonDao.getTaxaByCommonName("common%", null,
+ MatchMode.BEGINNING, null, null, null, null);
+
+ assertNotNull("getTaxaByCommonName should return a list", commonNameResults);
+ assertFalse("the list should not be empty", commonNameResults.isEmpty());
+ assertEquals("There should be two taxa with common name", 2,commonNameResults.size());
+
+ List<UuidAndTitleCache<Taxon>> 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(){
+ //Test that BeanInitializer also works on HiberanteProxys
+ Classification c = classificationDao.load(UUID.fromString("4bceea53-893f-4685-8c63-6dcec6e85ab1"));
+ TaxonNode singleNode = c.getRootNode().getChildNodes().iterator().next();
+ Taxon taxonProxy = singleNode.getTaxon();
+ Assert.assertTrue("Object to test should be a proxy ", taxonProxy instanceof HibernateProxy);
+
+ List<String> propertyPaths = new ArrayList<>();
+ propertyPaths.add("taxonNodes");
+ Taxon taxon = (Taxon)this.taxonDao.load(
+ UUID.fromString("4a5bc930-844f-45ec-aea8-dd155e1ab25f"),
+ propertyPaths);
+ Assert.assertSame("Returned object should be the same proxy to assure that we ran initialization on this proxy", taxonProxy, taxon);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+// @Test
+ public void createTestDataSet() throws FileNotFoundException {
+// Classification classification = Classification.NewInstance("Test");
+// BotanicalName TaxonName = null;
+// Reference sec = null;
+// Taxon taxon = Taxon.NewInstance(taxonName, sec);
+// classification.addChildTaxon(taxon, sec, null);
+//
+// classificationDao.save(classification);
+// this.commitAndStartNewTransaction(null);
+//
+// writeDbUnitDataSetFile(new String[] {
+// "CLASSIFICATION", "TAXONNAME",
+// "REFERENCE","TAXONNODE",
+// "TAXONBASE","LANGUAGESTRING",
+// "HIBERNATE_SEQUENCES" // IMPORTANT!!!
+// },
+// "testPropertyPath" );
+ }
+
+}
BGBM BDI Projects / cdmlib.git / blobdiff