cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/description/DescriptionDaoHibernateImplTest.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.persistence.dao.hibernate.description;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertFalse;
  14 import static org.junit.Assert.assertNotNull;
  15
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.junit.Before;
  22 import org.junit.Test;
  23 import org.unitils.dbunit.annotation.DataSet;
  24 import org.unitils.spring.annotation.SpringBeanByType;
  25
  26 import eu.etaxonomy.cdm.model.description.AbsenceTerm;
  27 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  28 import eu.etaxonomy.cdm.model.description.Feature;
  29 import eu.etaxonomy.cdm.model.description.PresenceTerm;
  30 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  31 import eu.etaxonomy.cdm.model.description.TextData;
  32 import eu.etaxonomy.cdm.model.location.NamedArea;
  33 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  34 import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;
  35 import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
  36
  37 @DataSet
  38 public class DescriptionDaoHibernateImplTest extends CdmIntegrationTest {
  39
  40         @SpringBeanByType
  41         IDescriptionDao descriptionDao;
  42
  43         @SpringBeanByType
  44         IDefinedTermDao definedTermDao;
  45
  46         private Set<NamedArea> namedAreas;
  47         private Set<Feature> features;
  48
  49         private UUID northernAmericaUuid;
  50         private UUID southernAmericaUuid;
  51         private UUID antarcticaUuid;
  52
  53         private UUID uuid;
  54
  55         @Before
  56         public void setUp() {
  57                 uuid = UUID.fromString("5f3265ed-68ad-4ec3-826f-0d29d25986b9");
  58
  59                 namedAreas = new HashSet<NamedArea>();
  60                 northernAmericaUuid = UUID.fromString("2757e726-d897-4546-93bd-7951d203bf6f");
  61                 southernAmericaUuid = UUID.fromString("6310b3ba-96f4-4855-bb5b-326e7af188ea");
  62                 antarcticaUuid = UUID.fromString("791b3aa0-54dd-4bed-9b68-56b4680aad0c");
  63
  64                 features = new HashSet<Feature>();
  65         }
  66
  67
  68         @Test
  69         public void testCountByDistribution() {
  70                 NamedArea northernAmerica = (NamedArea)definedTermDao.findByUuid(northernAmericaUuid);
  71                 NamedArea southernAmerica = (NamedArea)definedTermDao.findByUuid(southernAmericaUuid);
  72                 NamedArea antarctica = (NamedArea)definedTermDao.findByUuid(antarcticaUuid);
  73
  74                 assert northernAmerica != null : "term must exist";
  75                 assert southernAmerica != null : "term must exist";
  76                 assert antarctica != null : "term must exist";
  77
  78                 namedAreas.add(northernAmerica);
  79                 namedAreas.add(southernAmerica);
  80                 namedAreas.add(antarctica);
  81
  82                 int numberOfDescriptions = descriptionDao.countDescriptionByDistribution(namedAreas, null);
  83                 assertEquals("countDescriptionsByDistribution should return 23",23,numberOfDescriptions);
  84         }
  85
  86         @Test
  87         public void testCountByDistributionWithStatus() {
  88                 NamedArea northernAmerica = (NamedArea)definedTermDao.findByUuid(northernAmericaUuid);
  89                 NamedArea southernAmerica = (NamedArea)definedTermDao.findByUuid(southernAmericaUuid);
  90                 NamedArea antarctica = (NamedArea)definedTermDao.findByUuid(antarcticaUuid);
  91
  92                 assert northernAmerica != null : "term must exist";
  93                 assert southernAmerica != null : "term must exist";
  94                 assert antarctica != null : "term must exist";
  95
  96                 namedAreas.add(northernAmerica);
  97                 namedAreas.add(southernAmerica);
  98                 namedAreas.add(antarctica);
  99
 100                 int numberOfDescriptions = descriptionDao.countDescriptionByDistribution(namedAreas, PresenceTerm.PRESENT());
 101                 assertEquals("countDescriptionsByDistribution should return 20",20,numberOfDescriptions);
 102         }
 103
 104         @Test
 105         public void testGetByDistribution() {
 106                 NamedArea northernAmerica = (NamedArea)definedTermDao.findByUuid(northernAmericaUuid);
 107                 NamedArea southernAmerica = (NamedArea)definedTermDao.findByUuid(southernAmericaUuid);
 108                 NamedArea antarctica = (NamedArea)definedTermDao.findByUuid(antarcticaUuid);
 109
 110                 assert northernAmerica != null : "term must exist";
 111                 assert southernAmerica != null : "term must exist";
 112                 assert antarctica != null : "term must exist";
 113
 114                 namedAreas.add(northernAmerica);
 115                 namedAreas.add(southernAmerica);
 116                 namedAreas.add(antarctica);
 117
 118                 List<TaxonDescription> descriptions = descriptionDao.searchDescriptionByDistribution(namedAreas, null, 10,2);
 119                 assertNotNull("searchDescriptionByDistribution should return a List",descriptions);
 120                 assertFalse("searchDescriptionsByDistribution should not be empty",descriptions.isEmpty());
 121                 assertEquals("searchDescriptionsByDistribution should return 3 elements",3,descriptions.size());
 122         }
 123
 124         @Test
 125         public void testGetByDistributionWithStatus() {
 126                 NamedArea northernAmerica = (NamedArea)definedTermDao.findByUuid(northernAmericaUuid);
 127                 NamedArea southernAmerica = (NamedArea)definedTermDao.findByUuid(southernAmericaUuid);
 128                 NamedArea antarctica = (NamedArea)definedTermDao.findByUuid(antarcticaUuid);
 129
 130                 assert northernAmerica != null : "term must exist";
 131                 assert southernAmerica != null : "term must exist";
 132                 assert antarctica != null : "term must exist";
 133
 134                 namedAreas.add(northernAmerica);
 135                 namedAreas.add(southernAmerica);
 136                 namedAreas.add(antarctica);
 137
 138                 List<TaxonDescription> descriptions = descriptionDao.searchDescriptionByDistribution(namedAreas, AbsenceTerm.ABSENT(), 10,0);
 139                 assertNotNull("searchDescriptionByDistribution should return a List",descriptions);
 140                 assertFalse("searchDescriptionsByDistribution should not be empty",descriptions.isEmpty());
 141                 assertEquals("searchDescriptionsByDistribution should return 3 elements",3,descriptions.size());
 142         }
 143
 144         @Test
 145         public void testCountDescriptionsWithText() {
 146                 int numberOfDescriptions = descriptionDao.countDescriptions(TaxonDescription.class, null, true, null);
 147
 148                 assertNotNull("countDescriptions should return a 2",numberOfDescriptions);
 149         }
 150
 151         @Test
 152         public void testListDescriptionsWithText() {
 153                 List<TaxonDescription> descriptions = descriptionDao.listDescriptions(TaxonDescription.class, null, true, null,null,null);
 154
 155                 assertNotNull("listDescriptions should return a List",descriptions);
 156                 assertFalse("listDescriptions should not be empty", descriptions.isEmpty());
 157                 assertEquals("listDescriptions should return 2 descriptions",2,descriptions.size());
 158         }
 159
 160         @Test
 161         public void testCountDescriptionsWithTextAndFeatures() {
 162                 features.add(Feature.ECOLOGY());
 163                 int numberOfDescriptions = descriptionDao.countDescriptions(TaxonDescription.class, null, true, features);
 164
 165                 assertNotNull("countDescriptions should return a 1",numberOfDescriptions);
 166         }
 167
 168         @Test
 169         public void testListDescriptionsWithTextAndFeatures() {
 170                 features.add(Feature.ECOLOGY());
 171                 List<TaxonDescription> descriptions = descriptionDao.listDescriptions(TaxonDescription.class, null, true, features,null,null);
 172
 173                 assertNotNull("listDescriptions should return a List",descriptions);
 174                 assertFalse("listDescriptions should not be empty", descriptions.isEmpty());
 175                 assertEquals("listDescriptions should return 1 descriptions",1,descriptions.size());
 176         }
 177
 178         @Test
 179         public void testCountDescriptionElements() {
 180                 DescriptionBase description = descriptionDao.findByUuid(uuid);
 181                 assert description != null : "description must exist";
 182
 183                 int numberOfDescriptionElements = descriptionDao.countDescriptionElements(description, null, TextData.class);
 184
 185                 assertEquals("countDescriptionElements should return 2",2,numberOfDescriptionElements);
 186         }
 187
 188         @Test
 189         public void testGetDescriptionElements() {
 190                 DescriptionBase description = descriptionDao.findByUuid(uuid);
 191                 assert description != null : "description must exist";
 192
 193                 List<TextData> elements = descriptionDao.getDescriptionElements(description, null, TextData.class, null, null);
 194
 195                 assertNotNull("getDescriptionElements should return a List");
 196                 assertFalse("getDescriptionElements should not be empty",elements.isEmpty());
 197                 assertEquals("getDescriptionElement should return 2 elements",2,elements.size());
 198         }
 199
 200         @Test
 201         public void testCountDescriptionElementsFeature() {
 202                 features.add(Feature.ECOLOGY());
 203                 DescriptionBase description = descriptionDao.findByUuid(uuid);
 204                 assert description != null : "description must exist";
 205
 206                 int numberOfDescriptionElements = descriptionDao.countDescriptionElements(description, features, TextData.class);
 207
 208                 assertEquals("countDescriptionElements should return 1",1,numberOfDescriptionElements);
 209         }
 210
 211         @Test
 212         public void testGetDescriptionElementsByFeature() {
 213                 features.add(Feature.ECOLOGY());
 214                 DescriptionBase description = descriptionDao.findByUuid(uuid);
 215                 assert description != null : "description must exist";
 216
 217                 List<TextData> elements = descriptionDao.getDescriptionElements(description, features, TextData.class, null, null);
 218
 219                 assertNotNull("getDescriptionElements should return a List");
 220                 assertFalse("getDescriptionElements should not be empty",elements.isEmpty());
 221                 assertEquals("getDescriptionElement should return 1 elements",1,elements.size());
 222         }
 223
 224 }