X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/e08838f0d687a639dc2ed1db09da3b1ac8910d2d..d2f1dbf2c82afa64d69d596895b5cfca90c11ce8:/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java diff --git a/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java b/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java index 0ba6dba2d0..274e2800b4 100644 --- a/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java +++ b/cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java @@ -57,6 +57,7 @@ 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; @@ -77,6 +78,9 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @SpringBeanByType private ITaxonDao taxonDao; + @SpringBeanByType + private ITaxonNodeDao taxonNodeDao; + @SpringBeanByType private IClassificationDao classificationDao; @@ -84,28 +88,45 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { private IReferenceDao referenceDao; @SpringBeanByType - IDefinedTermDao definedTermDao; - - private UUID uuid; - private UUID sphingidae; - private UUID acherontia; - private UUID rethera; - private UUID retheraSecCdmtest; - private UUID atroposAgassiz; // a Synonym - private UUID atroposLeach; // a Synonym - private UUID acherontiaLachesis; + private IDefinedTermDao definedTermDao; + + private UUID uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); + private UUID sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9"); + private UUID acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa"); + private UUID rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); + private UUID retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); + private UUID atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1"); // a Synonym + private UUID atroposOken = UUID.fromString("6bfedf25-6dbc-4d5c-9d56-84f9052f3b2a"); // a Synonym + private UUID atroposLeach = UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07"); // a Synonym + private UUID acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06"); + private UUID aus = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); + + private UUID UUID_ACHERONTIA_NODE = UUID.fromString("56b10cf0-9522-407e-9f90-0c2dba263c94"); + private UUID UUID_CLASSIFICATION2 = UUID.fromString("a71467a6-74dc-4148-9530-484628a5ab0e"); private AuditEvent previousAuditEvent; private AuditEvent mostRecentAuditEvent; private UUID northernAmericaUuid; private UUID southernAmericaUuid; - private UUID antarcticaUuid; private UUID classificationUuid; private boolean includeUnpublished = true; + private boolean NO_UNPUBLISHED = false; + + private static final boolean doTaxa = true; + private static final boolean noTaxa = false; + private static final boolean doSynonyms = true; + private static final boolean noSynonyms = false; + private static final boolean doMisapplied = true; + private static final boolean noMisapplied = false; + private static final boolean doCommonNames = true; + private static final boolean noCommonNames = false; + + + @SuppressWarnings("unused") private static final String[] TABLE_NAMES = new String[] { "HOMOTYPICALGROUP", "HOMOTYPICALGROUP_AUD", "REFERENCE", "REFERENCE_AUD", "TAXONBASE", "TAXONBASE_AUD" , "TAXONNAME", "TAXONNAME_AUD", "TAXONRELATIONSHIP", "TAXONRELATIONSHIP_AUD" }; @@ -114,14 +135,6 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Before public void setUp() { - uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2"); - sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9"); - acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa"); - acherontiaLachesis = UUID.fromString("b04cc9cb-2b4a-4cc4-a94a-3c93a2158b06"); - atroposAgassiz = UUID.fromString("d75b2e3d-7394-4ada-b6a5-93175b8751c1"); - atroposLeach = UUID.fromString("3da4ab34-6c50-4586-801e-732615899b07"); - rethera = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); - retheraSecCdmtest = UUID.fromString("a9f42927-e507-4fda-9629-62073a908aae"); previousAuditEvent = new AuditEvent(); previousAuditEvent.setRevisionNumber(1025); @@ -133,7 +146,6 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f"); southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea"); - antarcticaUuid = UUID.fromString("791b3aa0-54dd-4bed-9b68-56b4680aad0c"); classificationUuid = UUID.fromString("aeee7448-5298-4991-b724-8d5b75a0a7a9"); includeUnpublished = true; @@ -155,9 +167,6 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertNotNull("Instance of IReferenceDao expected",referenceDao); } - /** - * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)}. - */ @Test @DataSet public void testGetTaxaByName() { @@ -168,6 +177,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Reference sec = referenceDao.findById(1); assert sec != null : "sec must exist"; + @SuppressWarnings("rawtypes") List results = taxonDao.getTaxaByName("Aus", includeUnpublished, sec); assertNotNull("getTaxaByName should return a List", results); //assertFalse("The list should not be empty", results.isEmpty()); @@ -221,56 +231,58 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testGetTaxaByNameWithMisappliedNames(){ Classification classification = classificationDao.load(classificationUuid); - + TaxonNode subtree = null; /* NOTE: - * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis), two contained in the classification used in this test, - * the other one is not contained in any classification. This latter case is the more general situation. + * The testdata contains 3 misapplied names (1. nameCache = Aus, 2. nameCache = Rethera, 3. nameCache = Daphnis), + * two contained in the classification used in this test, + * the other one is not contained in any classification. This later case is the more general situation. * Misapplied names should be found regardless of whether they are contained in a classification or not. */ //two accepted taxa starting with R in classification "TestBaum" - List results = taxonDao.getTaxaByName(true, false, false, false, false, "R*", classification, MatchMode.BEGINNING, + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "R*", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 2 Taxa", 2, results.size()); //three taxa, 2 accepted and 1 misapplied name starting with R - results = taxonDao.getTaxaByName(true, false, true, false, false, "R*", null, MatchMode.BEGINNING, + 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(true, true, true, false, false, "A*", null, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "A*", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 11 Taxa",11, results.size()); //two accepted taxa in classification and 1 misapplied name with accepted name in classification - results = taxonDao.getTaxaByName(true, true, true, false, false, "R*", classification, MatchMode.BEGINNING, + 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(true, true, true, false, false, "R*", classification, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); includeUnpublished = true; //same as above because all taxa, synonyms and misapplied names starting with R are in the classification - results = taxonDao.getTaxaByName(true, true, true, false, false, "R*", null, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 3 Taxa", 3, results.size()); //find misapplied names with accepted taxon in the classification, the accepted taxa of two misapplied names are in the classification - results = taxonDao.getTaxaByName(false, false, true, false, false, "*", classification, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "*", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 2 Taxa", 2, results.size()); //find misapplied names beginning with R - results = taxonDao.getTaxaByName(false, false, true, false, false, "R*", null, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "R*", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 1 Taxa", 1, results.size()); //find all three misapplied names - results = taxonDao.getTaxaByName(false, false, true, false, false, "*", null, MatchMode.BEGINNING, + 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()); @@ -281,32 +293,36 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet (loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testGetTaxaByNameVariants(){ - List results = taxonDao.getTaxaByName(false, false, false, true, false, "c*", null, MatchMode.BEGINNING, + TaxonNode subtree = null; + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 2 Taxa",2, results.size()); - results = taxonDao.getTaxaByName(false, false, true, true, false, "R*", null, MatchMode.BEGINNING, + 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(false, true, true, true, false, "R*", null, MatchMode.BEGINNING, + 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(false, true, false, true, false, "c*", null, MatchMode.BEGINNING, + 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(true, false, false, true, false, "c*", null, MatchMode.BEGINNING, + 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(false, false, false, true, false, "c*", classification, MatchMode.BEGINNING, + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "c*", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Assert.assertEquals("There should be 1 Taxa", 1, results.size()); + Set namedAreas = new HashSet<>(); namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); - results = taxonDao.getTaxaByName(false, false, false, true, false, "c*", null, MatchMode.BEGINNING, + 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()); } @@ -317,35 +333,38 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxaByNameForEditor() { + TaxonNode subtree = null; Reference sec = referenceDao.findById(1); assert sec != null : "sec must exist"; - List> results = taxonDao.getTaxaByNameForEditor(true, true, false,false, false, includeUnpublished, "Acher", null, MatchMode.BEGINNING, null, null); + @SuppressWarnings("rawtypes") + List> results = taxonDao.getTaxaByNameForEditor( + doTaxa, doSynonyms, noMisapplied, noCommonNames, false, includeUnpublished, "Acher", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); assertFalse("The list should not be empty", results.isEmpty()); assertEquals(4, results.size()); - results = taxonDao.getTaxaByNameForEditor(true, true, false, false,false,includeUnpublished, "A",null, MatchMode.BEGINNING, null, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "A",null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals(7, results.size()); - results = taxonDao.getTaxaByNameForEditor(true, false,false, false,false, includeUnpublished, "A", null,MatchMode.BEGINNING, null, null); + 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(false, true,false,false, false,includeUnpublished, "A", null,MatchMode.BEGINNING, null, null); + 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(true, true,false,false,false,includeUnpublished, "Aus", null,MatchMode.EXACT, null, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,includeUnpublished, "Aus", null, subtree, MatchMode.EXACT, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals("Results list should contain one entity",1,results.size()); - results = taxonDao.getTaxaByNameForEditor(true, true,true,false,false,includeUnpublished, "A", null,MatchMode.BEGINNING, null, null); + results = taxonDao.getTaxaByNameForEditor(doTaxa, doSynonyms, doMisapplied, noCommonNames, false, includeUnpublished, "A", null, subtree, MatchMode.BEGINNING, null, null); assertNotNull("getTaxaByName should return a List", results); assertEquals("Results list should contain one entity", 8, results.size()); @@ -361,49 +380,50 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testGetTaxaByNameAndArea() { - + TaxonNode subtree = null; Set namedAreas = new HashSet<>(); namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid)); - Classification taxonmicTree = classificationDao.findByUuid(classificationUuid); + Classification classification = classificationDao.findByUuid(classificationUuid); // prepare some synonym relation ships for some tests Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz); Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera); taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF()); - logger.warn("addSynonym(..)"); +// 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 taxonRetheraSecCdmTest = (Taxon)taxonDao.findByUuid(retheraSecCdmtest); + taxonRetheraSecCdmTest.addSynonym(synAtroposLeach, SynonymType.SYNONYM_OF()); + this.taxonDao.save(taxonRetheraSecCdmTest); Taxon test = (Taxon)this.taxonDao.findByUuid(retheraSecCdmtest); // Set synonyms3 = test.getSynonyms(); // 1. searching for a taxon (Rethera) //long numberOfTaxa = taxonDao.countTaxaByName(Taxon.class, "Rethera", null, MatchMode.BEGINNING, namedAreas); - List results = taxonDao.getTaxaByName(true,false, false, false, false,"Rethera", null, MatchMode.BEGINNING, namedAreas, + @SuppressWarnings("rawtypes") + List results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", null, subtree, MatchMode.BEGINNING, namedAreas, includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); - results = taxonDao.getTaxaByName(false,false, false, true, false, "com*", null, MatchMode.BEGINNING, namedAreas, + results = taxonDao.getTaxaByName(noTaxa, noSynonyms, noMisapplied, doCommonNames, false, "com*", null, subtree, MatchMode.BEGINNING, namedAreas, includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); // 2. searching for a taxon (Rethera) contained in a specific classification - results = taxonDao.getTaxaByName(true, false, false, false, false, "Rethera", taxonmicTree, MatchMode.BEGINNING, namedAreas, + results = taxonDao.getTaxaByName(doTaxa, noSynonyms, noMisapplied, noCommonNames, false, "Rethera", classification, subtree, MatchMode.BEGINNING, namedAreas, includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); // 3. searching for Synonyms - results = taxonDao.getTaxaByName(false, true, false, false, false, "Atropo", null, MatchMode.ANYWHERE, null, + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "Atropo", null, subtree, MatchMode.ANYWHERE, null, includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); /*System.err.println(results.get(0).getTitleCache() + " - " +results.get(1).getTitleCache() + " - " +results.get(2).getTitleCache() ); @@ -414,14 +434,14 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3); // 4. searching for Synonyms - results = taxonDao.getTaxaByName(false, true, false, false, false,"Atropo", null, MatchMode.BEGINNING, null, + results = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false,"Atropo", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find three taxa but found "+results.size(), results.size() == 3); // 5. searching for a Synonyms and Taxa - results = taxonDao.getTaxaByName(true, true, false, false, false,"A", null, MatchMode.BEGINNING, namedAreas, + 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); @@ -430,14 +450,15 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { /** - * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Classclazz, String queryString, Classification classification, MatchMode matchMode, Set namedAreas, Integer pageNumber, Integer pageSize, List propertyPaths)} + * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#findByNameTitleCache(Classclazz, String queryString, Classification classification, TaxonNode subtree, MatchMode matchMode, Set namedAreas, Integer pageNumber, Integer pageSize, List propertyPaths)} * restricting the search by a set of Areas. */ @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testFindByNameTitleCache() { + TaxonNode subtree = null; - Set namedAreas = new HashSet(); + Set namedAreas = new HashSet<>(); namedAreas.add((NamedArea)definedTermDao.load(northernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(southernAmericaUuid)); //namedAreas.add((NamedArea)definedTermDao.load(antarcticaUuid)); @@ -448,41 +469,40 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Synonym synAtroposAgassiz = (Synonym)taxonDao.findByUuid(atroposAgassiz); Taxon taxonRethera = (Taxon)taxonDao.findByUuid(rethera); taxonRethera.addSynonym(synAtroposAgassiz, SynonymType.SYNONYM_OF()); - logger.warn("addSynonym(..)"); + //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); - List results = taxonDao.findByNameTitleCache(true, false, includeUnpublished, "Rethera Rothschild & Jordan, 1903", null, MatchMode.EXACT, namedAreas, + @SuppressWarnings("rawtypes") + List results = taxonDao.findByNameTitleCache(doTaxa, noSynonyms, includeUnpublished, "Rethera Rothschild & Jordan, 1903", null, subtree, MatchMode.EXACT, namedAreas, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); // 2. searching for a taxon (Rethera) contained in a specific classification - results = taxonDao.findByNameTitleCache(true, false, includeUnpublished, "Rethera Rothschild & Jordan, 1903", classification, MatchMode.EXACT, namedAreas, + results = taxonDao.findByNameTitleCache(doTaxa, noSynonyms, includeUnpublished, "Rethera Rothschild & Jordan, 1903", classification, subtree, MatchMode.EXACT, namedAreas, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find one taxon but found "+results.size(), results.size() == 1); - // 3. searching for Synonyms - results = taxonDao.findByNameTitleCache(false, true, includeUnpublished, "*Atropo", null, MatchMode.ANYWHERE, null, + results = taxonDao.findByNameTitleCache(noTaxa, doSynonyms, includeUnpublished, "*Atropo", null, subtree, MatchMode.ANYWHERE, null, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); - assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); // 4. searching for Synonyms - results = taxonDao.findByNameTitleCache(false, true, includeUnpublished, "Atropo", null, MatchMode.BEGINNING, null, + results = taxonDao.findByNameTitleCache(noTaxa, doSynonyms, includeUnpublished, "Atropo", null, subtree, MatchMode.BEGINNING, null, null, null, null, null); assertNotNull("getTaxaByName should return a List", results); assertTrue("expected to find two taxa but found "+results.size(), results.size() == 2); - // 5. searching for a Synonyms and Taxa // attache a synonym first Synonym syn = (Synonym)taxonDao.findByUuid(this.atroposLeach); @@ -490,7 +510,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { tax.addSynonym(syn, SynonymType.HETEROTYPIC_SYNONYM_OF()); taxonDao.save(tax); - results = taxonDao.findByNameTitleCache(true, true, includeUnpublished, "A", null, MatchMode.BEGINNING, namedAreas, + 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); @@ -499,10 +519,11 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") public void testTaxonNameInTwoClassifications(){ - int numberOfClassifications = classificationDao.count(); + TaxonNode subtree = null; List propertyPaths = new ArrayList<>(); propertyPaths.add("taxonNodes"); - List taxa = taxonDao.getTaxaByName(true, true, false, false, false,"P", null, MatchMode.BEGINNING, + @SuppressWarnings("rawtypes") + List taxa = taxonDao.getTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false,"P", null, subtree, MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); Taxon taxon = (Taxon)taxa.get(0); Set nodes = taxon.getTaxonNodes(); @@ -511,6 +532,32 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { //assertTrue(taxa.size() > 0); } + @Test + @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonDaoHibernateImplTest.testGetTaxaByNameAndArea.xml") + public void testGetTaxaByNameProParteSynonym(){ + TaxonNode subtree = null; + @SuppressWarnings("rawtypes") + List taxa = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); + Assert.assertEquals("2 synonyms and 1 pro parte synonym should be returned.", 3, taxa.size()); + assertTrue("Pro parte should exist", existsInCollection(taxa, acherontiaLachesis)); + assertTrue("Normal synonym should exist", existsInCollection(taxa, atroposAgassiz)); + assertTrue("2. normal synonym should exist", existsInCollection(taxa, atroposOken)); + //TODO shouldn't we also find orphaned synonyms (without accepted taxon) like Atropos Leach? + + taxa = taxonDao.getTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, NO_UNPUBLISHED, null, null, null, null); + Assert.assertEquals("2 synonyms and no pro parte synonym should be returned.", 2, taxa.size()); + assertTrue("Normal synonym should exist", existsInCollection(taxa, atroposAgassiz)); + assertTrue("2. normal synonym should exist", existsInCollection(taxa, atroposOken)); + + taxa = taxonDao.getTaxaByName(noTaxa, noSynonyms, doMisapplied, noCommonNames, false, "A", null,subtree, + MatchMode.BEGINNING, null, includeUnpublished, null, null, null, null); + Assert.assertEquals("1 misapplied name, no pro parte synonym should be returned.", 1, taxa.size()); + assertTrue("Pro parte should exist", existsInCollection(taxa, aus)); + + } + @Test @DataSet public void testFindByUuid() { @@ -537,7 +584,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon must exist"; - int numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + long numberOfRelatedTaxa = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), includeUnpublished, TaxonRelationship.Direction.relatedTo); assertEquals("countTaxonRelationships should return 8", 8, numberOfRelatedTaxa); } @@ -545,20 +592,49 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testCountTaxaByName() { - long numberOfTaxa = taxonDao.countTaxaByName(true, false, false, false,false, "A", null, MatchMode.BEGINNING, null, includeUnpublished); + 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(true, false, false, false, false,"Smerinthus kindermannii", null, MatchMode.EXACT, null, includeUnpublished); + 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(false, true, false, false, false,"A", null, MatchMode.BEGINNING, null, includeUnpublished); + numberOfTaxa = taxonDao.countTaxaByName(noTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); assertEquals(2, numberOfTaxa); - numberOfTaxa = taxonDao.countTaxaByName(true, true, false, false, false,"A", null, MatchMode.BEGINNING, null, includeUnpublished); + numberOfTaxa = taxonDao.countTaxaByName(doTaxa, doSynonyms, noMisapplied, noCommonNames, false, "A", classification, subtree, MatchMode.BEGINNING, null, includeUnpublished); assertEquals(7, numberOfTaxa); - numberOfTaxa = taxonDao.countTaxaByName(true, true, false, false,false, "Aasfwerfwf fffe", null, MatchMode.BEGINNING, null, includeUnpublished); + 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); -// FIXME implement test for search in specific classification -// Reference reference = referenceDao.findByUuid(UUID.fromString("596b1325-be50-4b0a-9aa2-3ecd610215f2")); -// numberOfTaxa = taxonDao.countTaxaByName("A*", MatchMode.BEGINNING, SelectMode.ALL, null, null); -// assertEquals(numberOfTaxa, 2); } @Test @@ -575,7 +651,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { orderHints.add(new OrderHint("relatedFrom.name.specificEpithet", SortOrder.ASCENDING)); orderHints.add(new OrderHint("relatedFrom.name.infraSpecificEpithet", SortOrder.ASCENDING)); - int count = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + long count = taxonDao.countTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), includeUnpublished, TaxonRelationship.Direction.relatedTo); assertEquals("Count should return 8 (related taxa)", 8, count); @@ -749,6 +825,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxonMatchingUninomial() { + @SuppressWarnings("rawtypes") List result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", "*", "*", "*","*",null,null,null); assertNotNull("findTaxaByName should return a List", result); @@ -759,6 +836,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxonMatchingSpeciesBinomial() { + @SuppressWarnings("rawtypes") List result = taxonDao.findTaxaByName(Taxon.class, "Smerinthus", null, "kindermannii", null,"*",null,null,null); assertNotNull("findTaxaByName should return a List", result); @@ -769,6 +847,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testGetTaxonMatchingTrinomial() { + @SuppressWarnings("rawtypes") List result = taxonDao.findTaxaByName(Taxon.class,"Cryptocoryne", null,"purpurea","borneoensis","*",null,null,null); assertNotNull("findTaxaByName should return a List", result); @@ -779,6 +858,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testNegativeMatch() { + @SuppressWarnings("rawtypes") List result = taxonDao.findTaxaByName(Taxon.class,"Acherontia", null,"atropos","dehli",null,null,null,null); assertNotNull("findTaxaByName should return a List", result); @@ -788,7 +868,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @Test @DataSet public void testCountAllTaxa() { - int numberOfTaxa = taxonDao.count(Taxon.class); + long numberOfTaxa = taxonDao.count(Taxon.class); assertEquals("count should return 14 taxa", 14, numberOfTaxa); } @@ -874,6 +954,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(taxon, null,null,null,propertyPaths); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -887,6 +968,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(taxon, null,null,AuditEventSort.FORWARDS,null); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -899,7 +981,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; - int numberOfAuditEvents = taxonDao.countAuditEvents(taxon, null); + long numberOfAuditEvents = taxonDao.countAuditEvents(taxon, null); assertEquals("countAuditEvents should return 2",numberOfAuditEvents,2); } @@ -917,9 +999,10 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { @DataSet("TaxonDaoHibernateImplTest.testFindDeleted.xml") public void getPreviousAuditEventAtBeginning() { AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent); - TaxonBase taxon = taxonDao.findByUuid(sphingidae); + TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getPreviousAuditEvent(taxon); assertNull("getPreviousAuditEvent should return null if we're at the first audit event anyway",auditEvent); } @@ -931,6 +1014,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getNextAuditEvent(taxon); assertNotNull("getNextAuditEvent should not return null as there is at least one audit event after the current one",auditEvent); } @@ -942,6 +1026,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { TaxonBase taxon = taxonDao.findByUuid(sphingidae); assert taxon != null : "taxon cannot be null"; + @SuppressWarnings("rawtypes") AuditEventRecord auditEvent = taxonDao.getNextAuditEvent(taxon); assertNull("getNextAuditEvent should return null as there no more audit events after the current one",auditEvent); } @@ -991,7 +1076,8 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testCountRelations() { Taxon taxon = (Taxon)taxonDao.findByUuid(acherontiaLachesis); assert taxon != null : "taxon cannot be null"; - assertEquals("countRelatedTaxa should return 1 in the current view",1, taxonDao.countTaxonRelationships(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), + assertEquals("countRelatedTaxa should return 1 in the current view",1, taxonDao.countTaxonRelationships( + taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), includeUnpublished, TaxonRelationship.Direction.relatedTo)); } @@ -1010,9 +1096,9 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { orderHints.add(new OrderHint("relatedFrom.titleCache", SortOrder.ASCENDING)); List taxonRelations = taxonDao.getTaxonRelationships(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), - includeUnpublished, null, null,orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); + includeUnpublished, null, null, orderHints,propertyPaths, TaxonRelationship.Direction.relatedFrom); assertNotNull("getRelatedTaxa should return a list",taxonRelations); - assertTrue("there should be no TaxonRelationships in the list in the prior view",taxonRelations.isEmpty()); + assertTrue("there should be no TaxonRelationships in the list in the prior view", taxonRelations.isEmpty()); } @Test @@ -1062,6 +1148,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { List orderHints = new ArrayList<>(); orderHints.add(new NativeSqlOrderHint("case when {alias}.titleCache like 'C%' then 0 else 1 end",SortOrder.ASCENDING)); + @SuppressWarnings("rawtypes") List results = taxonDao.list(null, null, orderHints); if(logger.isTraceEnabled()){ System.out.println("native SQL order"); @@ -1099,7 +1186,7 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { public void testGetAuditEventsByTypeWithRestrictions() { commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); - List propertyPaths = new ArrayList(); + List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); @@ -1107,8 +1194,9 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { List criteria = new ArrayList<>(); criteria.add(AuditEntity.property("lsid_lsid").isNotNull()); - int count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, criteria,null, null, AuditEventSort.FORWARDS, propertyPaths); assertNotNull("getAuditEvents should return a list",auditEvents); assertFalse("the list should not be empty",auditEvents.isEmpty()); @@ -1128,14 +1216,15 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { //while those inserted by the terms dataset are inserted as well as a completely new one. //This problem for some reason does not happen if not running at first place public void testGetAuditEventsByTypeWithNoRestrictions() { - printDataSet(System.out, new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); +// printDataSet(System.out, new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); commitAndStartNewTransaction(new String[]{"AUDITEVENT", "TAXONBASE_AUD"}); List propertyPaths = new ArrayList<>(); propertyPaths.add("name"); propertyPaths.add("createdBy"); propertyPaths.add("updatedBy"); - int count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + long count = taxonDao.countAuditEvents(TaxonBase.class, null, null, null); + @SuppressWarnings("rawtypes") List> auditEvents = taxonDao.getAuditEvents(TaxonBase.class, previousAuditEvent, mostRecentAuditEvent, null,null, null, AuditEventSort.FORWARDS, propertyPaths); assertNotNull("getAuditEvents should return a list", auditEvents); assertFalse("the list should not be empty", auditEvents.isEmpty()); @@ -1153,11 +1242,12 @@ public class TaxonDaoHibernateImplTest extends CdmTransactionalIntegrationTest { assertFalse("the list should not be empty", commonNameResults.isEmpty()); assertEquals("There should be two taxa with common name", 2,commonNameResults.size()); - List> list = taxonDao.getTaxaByCommonNameForEditor("common%", null, MatchMode.BEGINNING, null); + List> list = taxonDao.getTaxaByCommonNameForEditor( + "common%", null, MatchMode.BEGINNING, null); - assertNotNull("getTaxaByCommonName should return a list", commonNameResults); - assertFalse("the list should not be empty", commonNameResults.isEmpty()); - assertEquals("There should be two Taxon with common name", 2,commonNameResults.size()); + 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()); }