cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/taxon/TaxonDaoHibernateImplTest.java

   1 package eu.etaxonomy.cdm.persistence.dao.hibernate.taxon;
   2
   3 import static junit.framework.Assert.assertEquals;
   4 import static junit.framework.Assert.assertFalse;
   5 import static junit.framework.Assert.assertNotNull;
   6 import static junit.framework.Assert.assertTrue;
   7
   8 import java.util.List;
   9 import java.util.UUID;
  10
  11 import org.hibernate.Hibernate;
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.unitils.dbunit.annotation.DataSet;
  15 import org.unitils.spring.annotation.SpringBeanByType;
  16
  17 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  18 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
  19 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  20 import eu.etaxonomy.cdm.model.taxon.Taxon;
  21 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  22 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
  23 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  24 import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;
  25 import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
  26 import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
  27
  28 /**
  29  * @author a.mueller
  30  * @author ben.clark
  31  *
  32  */
  33 public class TaxonDaoHibernateImplTest extends CdmIntegrationTest {
  34
  35         @SpringBeanByType
  36         private ITaxonDao taxonDao;
  37
  38         @SpringBeanByType
  39         private IReferenceDao referenceDao;
  40
  41         private UUID uuid;
  42         private UUID sphingidae;
  43         private UUID acherontia;
  44
  45         @Before
  46         public void setUp() {
  47                 uuid = UUID.fromString("496b1325-be50-4b0a-9aa2-3ecd610215f2");
  48                 sphingidae = UUID.fromString("54e767ee-894e-4540-a758-f906ecb4e2d9");
  49                 acherontia = UUID.fromString("c5cc8674-4242-49a4-aada-72d63194f5fa");
  50         }
  51
  52         /**
  53          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#TaxonDaoHibernateImpl()}.
  54          */
  55         @Test
  56         @DataSet
  57         public void testInit() {
  58                 assertNotNull("Instance of ITaxonDao expected",taxonDao);
  59         }
  60
  61         /**
  62          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getRootTaxa(eu.etaxonomy.cdm.model.reference.ReferenceBase)}.
  63          */
  64         @Test
  65         @DataSet
  66         public void testGetRootTaxa() {
  67                 ReferenceBase sec = referenceDao.findById(1);
  68                 assert sec != null : "sec must exist";
  69
  70                 List<Taxon> rootTaxa = taxonDao.getRootTaxa(sec);
  71                 assertNotNull("getRootTaxa should return a List",rootTaxa);
  72                 assertFalse("The list should not be empty",rootTaxa.isEmpty());
  73                 assertEquals("There should be one root taxon",1, rootTaxa.size());
  74         }
  75
  76         /**
  77          * Test method for {@link eu.etaxonomy.cdm.persistence.dao.hibernate.taxon.TaxonDaoHibernateImpl#getTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.ReferenceBase)}.
  78          */
  79         @Test
  80         @DataSet
  81         public void testGetTaxaByName() {
  82                 ReferenceBase sec = referenceDao.findById(1);
  83                 assert sec != null : "sec must exist";
  84
  85                 List<TaxonBase> results = taxonDao.getTaxaByName("Aus", sec);
  86                 assertNotNull("getTaxaByName should return a List",results);
  87                 assertFalse("The list should not be empty",results.isEmpty());
  88         }
  89
  90         @Test
  91         @DataSet
  92         public void testFindByUuid() {
  93                 Taxon taxon = (Taxon)taxonDao.findByUuid(uuid);
  94                 assertNotNull("findByUuid should return a taxon",taxon);
  95                 assertTrue("findByUuid should return a taxon with it's name initialized",Hibernate.isInitialized(taxon.getName()));
  96         }
  97
  98         @Test
  99         @DataSet
 100         public void testCountRelatedTaxa()      {
 101                 Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
 102                 assert taxon != null : "taxon must exist";
 103
 104                 int numberOfRelatedTaxa = taxonDao.countRelatedTaxa(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN());
 105                 assertEquals("countRelatedTaxa should return 23", 23, numberOfRelatedTaxa);
 106         }
 107
 108         @Test
 109         @DataSet
 110         public void testRelatedTaxa() {
 111                 Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
 112                 assert taxon != null : "taxon must exist";
 113
 114                 List<TaxonRelationship> relatedTaxa = taxonDao.getRelatedTaxa(taxon, TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), null, null);
 115                 assertNotNull("getRelatedTaxa should return a List",relatedTaxa);
 116                 assertEquals("getRelatedTaxa should return all 23 related taxa",relatedTaxa.size(),23);
 117                 assertTrue("getRelatedTaxa should return TaxonRelationship objects with the relatedFrom taxon initialized",Hibernate.isInitialized(relatedTaxa.get(0).getFromTaxon()));
 118         }
 119
 120         @Test
 121         @DataSet
 122         public void testGetRelatedTaxaPaged()   {
 123                 Taxon taxon = (Taxon)taxonDao.findByUuid(sphingidae);
 124                 assert taxon != null : "taxon must exist";
 125
 126                 List<TaxonRelationship> firstPage = taxonDao.getRelatedTaxa(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 0);
 127                 List<TaxonRelationship> secondPage = taxonDao.getRelatedTaxa(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),10, 1);
 128                 List<TaxonRelationship> thirdPage = taxonDao.getRelatedTaxa(taxon,TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(), 10, 2);
 129
 130                 assertNotNull("getRelatedTaxa: 10, 0 should return a List",firstPage);
 131                 assertEquals("getRelatedTaxa: 10, 0 should return a List with 10 elements",10,firstPage.size());
 132                 assertNotNull("getRelatedTaxa: 10, 1 should return a List",secondPage);
 133                 assertEquals("getRelatedTaxa: 10, 1 should return a List with 10 elements",secondPage.size(),10);
 134                 assertNotNull("getRelatedTaxa: 10, 2 should return a List",thirdPage);
 135                 assertEquals("getRelatedTaxa: 10, 2 should return a List with 3 elements",thirdPage.size(),3);
 136         }
 137
 138         @Test
 139         @DataSet
 140         public void testCountSynonymRelationships() {
 141                 Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
 142                 assert taxon != null : "taxon must exist";
 143
 144                 int numberOfSynonymRelationships = taxonDao.countSynonyms(taxon,null);
 145                 assertEquals("countSynonymRelationships should return 5",5,numberOfSynonymRelationships);
 146         }
 147
 148         @Test
 149         @DataSet
 150         public void testSynonymRelationships()  {
 151                 Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
 152                 assert taxon != null : "taxon must exist";
 153
 154                 List<SynonymRelationship> synonyms = taxonDao.getSynonyms(taxon, null, null, null);
 155
 156                 assertNotNull("getSynonyms should return a List",synonyms);
 157                 assertEquals("getSynonyms should return 5 SynonymRelationship entities",synonyms.size(),5);
 158                 assertTrue("getSynonyms should return SynonymRelationship objects with the synonym initialized",Hibernate.isInitialized(synonyms.get(0).getSynonym()));
 159         }
 160
 161         @Test
 162         @DataSet
 163         public void testCountSynonymRelationshipsByType()       {
 164                 Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
 165                 assert taxon != null : "taxon must exist";
 166
 167                 int numberOfTaxonomicSynonyms = taxonDao.countSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());
 168                 assertEquals("countSynonyms should return 4",numberOfTaxonomicSynonyms, 4);
 169         }
 170
 171         @Test
 172         @DataSet
 173         public void testSynonymRelationshipsByType() {
 174                 Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
 175                 assert taxon != null : "taxon must exist";
 176
 177         List<SynonymRelationship> synonyms = taxonDao.getSynonyms(taxon, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), null, null);
 178
 179         assertNotNull("getSynonyms should return a List",synonyms);
 180                 assertEquals("getSynonyms should return 4 SynonymRelationship entities",synonyms.size(),4);
 181         }
 182
 183         @Test
 184         @DataSet
 185         public void testPageSynonymRelationships(){
 186                 Taxon taxon = (Taxon)taxonDao.findByUuid(acherontia);
 187                 assert taxon != null : "taxon must exist";
 188
 189                 List<SynonymRelationship> firstPage = taxonDao.getSynonyms(taxon, null, 4, 0);
 190                 List<SynonymRelationship> secondPage = taxonDao.getSynonyms(taxon, null, 4, 1);
 191
 192                 assertNotNull("getSynonyms: 4, 0 should return a List",firstPage);
 193                 assertEquals("getSynonyms: 4, 0 should return 4 SynonymRelationships", firstPage.size(),4);
 194                 assertNotNull("getSynonyms: 4, 1 should return a List",secondPage);
 195                 assertEquals("getSynonyms: 4, 1 should return 1 SynonymRelationship",secondPage.size(),1);
 196         }
 197
 198         @Test
 199         @DataSet
 200         public void testGetTaxonMatchingUninomial() {
 201                 List<TaxonBase> result = taxonDao.findTaxaByName(true, "Smerinthus", null, null, null,null,null,null);
 202
 203                 assertNotNull("findTaxaByName should return a List", result);
 204                 assertEquals("findTaxaByName should return two Taxa",2,result.size());
 205                 assertEquals("findTaxaByName should return a Taxon with id 5",5,result.get(0).getId());
 206         }
 207
 208         @Test
 209         @DataSet
 210         public void testGetTaxonMatchingSpeciesBinomial() {
 211                 List<TaxonBase> result = taxonDao.findTaxaByName(true,"Smerinthus", null, "kindermannii", null,null,null,null);
 212
 213                 assertNotNull("findTaxaByName should return a List", result);
 214                 assertEquals("findTaxaByName should return one Taxon",1,result.size());
 215                 assertEquals("findTaxaByName should return a Taxon with id 8",8,result.get(0).getId());
 216         }
 217
 218         @Test
 219         @DataSet
 220         public void testGetTaxonMatchingTrinomial() {
 221                 List<TaxonBase> result = taxonDao.findTaxaByName(true,"Cryptocoryne", null,"purpurea","borneoensis",null,null,null);
 222
 223                 assertNotNull("findTaxaByName should return a List", result);
 224                 assertEquals("findTaxaByName should return one Taxon",1,result.size());
 225                 assertEquals("findTaxaByName should return a Taxon with id 38",38,result.get(0).getId());
 226         }
 227
 228         @Test
 229         @DataSet
 230         public void testNegativeMatch() {
 231                 List<TaxonBase> result = taxonDao.findTaxaByName(true,"Acherontia", null,"atropos","dehli",null,null,null);
 232
 233                 assertNotNull("findTaxaByName should return a List", result);
 234                 assertTrue("findTaxaByName should return an empty List",result.isEmpty());
 235         }
 236
 237         @Test
 238         @DataSet
 239         public void testCountAllTaxa() {
 240                 int numberOfTaxa = taxonDao.count(Taxon.class);
 241                 assertEquals("count should return 33 taxa",33, numberOfTaxa);
 242         }
 243
 244         @Test
 245         @DataSet
 246         public void testListAllTaxa() {
 247                 List<Taxon> taxa = taxonDao.list(Taxon.class,100, 0);
 248                 assertNotNull("list should return a List",taxa);
 249                 assertEquals("list should return 33 taxa",33, taxa.size());
 250         }
 251 }