cdmlib-persistence/src/test/java/eu/etaxonomy/cdm/persistence/dao/hibernate/name/TypeDesignationDaoHibernateImplTest.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 package eu.etaxonomy.cdm.persistence.dao.hibernate.name;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.io.FileNotFoundException;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import org.apache.logging.log4j.LogManager;
  21 import org.apache.logging.log4j.Logger;
  22 import org.junit.Assert;
  23 import org.junit.Test;
  24 import org.unitils.dbunit.annotation.DataSet;
  25 import org.unitils.dbunit.annotation.ExpectedDataSet;
  26 import org.unitils.spring.annotation.SpringBeanByType;
  27
  28 import eu.etaxonomy.cdm.model.common.CdmBase;
  29 import eu.etaxonomy.cdm.model.name.IBotanicalName;
  30 import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
  31 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  32 import eu.etaxonomy.cdm.model.name.Rank;
  33 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  34 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  35 import eu.etaxonomy.cdm.model.name.TaxonName;
  36 import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
  37 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  38 import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;
  39 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  40 import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
  41 import eu.etaxonomy.cdm.persistence.dao.name.ITypeDesignationDao;
  42 import eu.etaxonomy.cdm.persistence.dao.occurrence.IOccurrenceDao;
  43 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  44
  45 /**
  46  * @author a.babadshanjan
  47  * @author a.mueller
  48  * @since 25.05.2009
  49  */
  50 public class TypeDesignationDaoHibernateImplTest extends CdmTransactionalIntegrationTest {
  51
  52     @SuppressWarnings("unused")
  53         private static final Logger logger = LogManager.getLogger(TypeDesignationDaoHibernateImplTest.class);
  54
  55         @SpringBeanByType
  56         private ITypeDesignationDao typeDesignationDao;
  57
  58         @SpringBeanByType
  59         private ITaxonNameDao nameDao;
  60
  61         @SpringBeanByType
  62         private IOccurrenceDao occurrenceDao;
  63
  64         @Test
  65         public void testInit() {
  66                 assertNotNull("Instance of ITypeDesignationDao expected", typeDesignationDao);
  67         }
  68
  69         @Test
  70         @DataSet
  71         public void testGetAllTypeDesignations() {
  72                 List<TypeDesignationBase<?>> typeDesignations = typeDesignationDao.getAllTypeDesignations(100, 0);
  73                 assertEquals(2, typeDesignations.size());
  74                 SpecimenTypeDesignation specTypeDesig = null;
  75                 for (TypeDesignationBase<?> typeDesignation : typeDesignations) {
  76                     typeDesignation= CdmBase.deproxy(typeDesignation);
  77                         if (typeDesignation instanceof NameTypeDesignation) {
  78                             NameTypeDesignation ntd = (NameTypeDesignation)typeDesignation;
  79                             NameTypeDesignationStatus status = ntd.getTypeStatus();
  80                             assertTrue(status.isInstanceOf(NameTypeDesignationStatus.class));
  81                         } else if (typeDesignation instanceof SpecimenTypeDesignation) {
  82                                 Assert.assertNull("There should be only 1 specimen type designation but this is already the second", specTypeDesig);
  83                                 TypeDesignationStatusBase<?> typeDesignationStatus = ((SpecimenTypeDesignation)typeDesignation).getTypeStatus();
  84                                 assertTrue(typeDesignationStatus.isInstanceOf(SpecimenTypeDesignationStatus.class));
  85                                 specTypeDesig = CdmBase.deproxy(typeDesignation,SpecimenTypeDesignation.class);
  86                         }
  87                 }
  88                 @SuppressWarnings("null")
  89         Set<TaxonName> names = specTypeDesig.getTypifiedNames();
  90                 Assert.assertEquals("There should be exactly 1 typified name for the the specimen type designation", 1, names.size());
  91                 TaxonName singleName = names.iterator().next();
  92                 Assert.assertEquals("", UUID.fromString("61b1dcae-8aa6-478a-bcd6-080cf0eb6ad7"), singleName.getUuid());
  93         }
  94
  95         @Test
  96         @DataSet
  97         @ExpectedDataSet  //not yet necessary with current test
  98         public void testSaveTypeDesignations() {
  99                 List<TypeDesignationBase<?>> typeDesignations = typeDesignationDao.getAllTypeDesignations(100, 0);
 100                 assertEquals(typeDesignations.size(), 2);
 101                 SpecimenTypeDesignation specTypeDesig = null;
 102                 for (TypeDesignationBase<?> typeDesignation : typeDesignations) {
 103                         if (typeDesignation.isInstanceOf(SpecimenTypeDesignation.class)) {
 104                                 specTypeDesig = CdmBase.deproxy(typeDesignation,SpecimenTypeDesignation.class);
 105                         }
 106                 }
 107
 108                 TaxonName newName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 109                 newName.setUuid(UUID.fromString("c16c3bc5-d3d0-4676-91a1-848ebf011e7c"));
 110                 newName.setTitleCache("Name used as typified name", true);
 111                 newName.addTypeDesignation(specTypeDesig, false);
 112
 113                 nameDao.saveOrUpdate(newName);
 114 //              typeDesignationDao.saveOrUpdate(specTypeDesig);
 115
 116                 commitAndStartNewTransaction(null);
 117                 specTypeDesig = (SpecimenTypeDesignation)typeDesignationDao.load(specTypeDesig.getUuid());
 118                 Assert.assertNotNull("specimen type designation should exists in db", specTypeDesig);
 119                 specTypeDesig.getTypifiedNames().size();
 120                 Set<TaxonName> typifiedNames = specTypeDesig.getTypifiedNames();
 121                 Assert.assertEquals("There should be 2 typified names for this type designation now", 2, typifiedNames.size());
 122
 123 //              printDataSet(System.out, new String[]{"TaxonName","TaxonName_AUD",
 124 //                              "HomotypicalGroup","HomotypicalGroup_AUD",
 125 //                              "TypeDesignationBase","TypeDesignationBase_AUD",
 126 //                              "TaxonName_TypeDesignationBase", "TaxonName_TypeDesignationBase_AUD"
 127 //                              });
 128
 129         }
 130
 131         @Test
 132         @ExpectedDataSet
 133         public void testSaveTypeDesignationsBidirectionalCascade() {
 134                 SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 135                 desig1.setUuid(UUID.fromString("a1b8af89-b724-469b-b0ce-027c2199aadd"));
 136
 137                 TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 138                 name.setUuid(UUID.fromString("503d78dc-5d4c-4eb6-b682-0ab90fdee02c"));
 139                 name.setTitleCache("Name saved via cascade", true);
 140                 name.addTypeDesignation(desig1, false);
 141
 142                 typeDesignationDao.saveOrUpdate(desig1);
 143                 commit();
 144         }
 145
 146         @Test
 147         @ExpectedDataSet
 148         //Auditing didn't work for SpecimenTypeDesignations. See #2396
 149         public void testSaveTypeDesignationsWithAuditing() {
 150
 151
 152                 // creating new Typedesignation for a new Name:
 153
 154                 //  1. new TaxonName with UUID 8564287e-9654-4b8b-a38c-0ccdd9e885db
 155             TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 156                 name1.setTitleCache("Name1", true);
 157                 name1.setUuid(UUID.fromString("8564287e-9654-4b8b-a38c-0ccdd9e885db"));
 158                 //   2. new TypeDesignation with uuid ceca086e-e8d3-444e-abfb-c47f76835130
 159                 SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 160                 desig1.setUuid(UUID.fromString("ceca086e-e8d3-444e-abfb-c47f76835130"));
 161
 162 //              //REMOVE
 163 //              desig1.setOriginalInfo("orig");
 164 //
 165                 name1.addTypeDesignation(desig1, true);
 166
 167                 nameDao.saveOrUpdate(name1);
 168                 commitAndStartNewTransaction(new String[]{"TypeDesignationBase", "TypeDesignationBase_AUD"});
 169 //              System.out.println(desig1.getId());
 170 //              System.out.println(desig1.getUuid());
 171
 172 //              printDataSet(System.err, new String[]{"TaxonName","TaxonName_AUD",
 173 //                              "HomotypicalGroup","HomotypicalGroup_AUD",
 174 //                              "TypeDesignationBase","TypeDesignationBase_AUD",
 175 //                              "TaxonName_TypeDesignationBase","TaxonName_TypeDesignationBase_AUD"
 176 //                              });
 177         }
 178
 179         @Test
 180         @ExpectedDataSet
 181         public void testSaveTypeDesignationsCascadeToSpecimen() {
 182             TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 183                 name1.setTitleCache("Name1", true);
 184                 name1.setUuid(UUID.fromString("eb41f549-4a70-499b-a9a5-f2314880df07"));
 185
 186                 SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 187                 desig1.setUuid(UUID.fromString("6df85e4c-49fe-4eb5-acde-cf6c0c9fc3c5"));
 188                 name1.addTypeDesignation(desig1, true);
 189
 190                 DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
 191                 specimen.setUuid(UUID.fromString("f1a7c3b9-169c-4845-9b21-e77f863a8bce"));
 192                 specimen.setTitleCache("Specimen to cascade", true);
 193                 desig1.setTypeSpecimen(specimen);
 194
 195                 nameDao.saveOrUpdate(name1);
 196
 197                 this.setComplete();
 198                 this.endTransaction();
 199
 200 //              printDataSet(System.out, new String[]{"TaxonName","TaxonName_AUD","TypeDesignationBase","TypeDesignationBase_AUD",
 201 //                              "TaxonName_TypeDesignationBase","TaxonName_TypeDesignationBase_AUD",
 202 //                              "TaxonName_TypeDesignationBase","SpecimenOrObservationBase","SpecimenOrObservationBase_AUD",
 203 //                              "HomotypicalGroup","HomotypicalGroup_AUD"});
 204         }
 205
 206         @Test
 207         @ExpectedDataSet
 208         //test save from specimen to name via type designation
 209         public void testSaveTypeDesignationsCascadeFromSpecimen() {
 210                 IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 211                 name1.setTitleCache("Name1", true);
 212                 name1.setUuid(UUID.fromString("7ce3a355-8f7c-4417-a0b3-41869de4f60b"));
 213
 214                 SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 215                 desig1.setUuid(UUID.fromString("c0e03472-b9f9-4886-b3bd-c1c70dd21a5f"));
 216                 name1.addTypeDesignation(desig1, true);
 217
 218                 DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
 219                 specimen.setUuid(UUID.fromString("4c3231a9-336e-4b21-acf2-129683627de4"));
 220                 specimen.setTitleCache("Specimen to cascade", true);
 221                 desig1.setTypeSpecimen(specimen);
 222
 223                 occurrenceDao.saveOrUpdate(specimen);
 224                 commit();
 225         }
 226
 227         @Test
 228         @DataSet
 229         public void testGetTypeDesignationStatusInUse() {
 230             List<TypeDesignationStatusBase> statusTerms = typeDesignationDao.getTypeDesignationStatusInUse();
 231             assertEquals(2, statusTerms.size());
 232         }
 233
 234         @Test
 235 //      @ExpectedDataSet
 236         public void testRemoveTypeDesignationsFromName() {
 237                 IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 238                 name1.setTitleCache("Name1", true);
 239                 name1.setUuid(UUID.fromString("2cfc05fc-138e-452d-b4ea-8798134c7410"));
 240
 241                 IBotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
 242                 name2.setTitleCache("Name2", true);
 243                 name2.setUuid(UUID.fromString("7a12057d-2e99-471e-ac7e-633f1d0b5686"));
 244
 245                 SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 246                 desig1.setUuid(UUID.fromString("fe9f7711-de4a-4789-8045-86b2cb5c4358"));
 247                 name1.addTypeDesignation(desig1, true);
 248                 name2.addTypeDesignation(desig1, true);
 249
 250                 SpecimenTypeDesignation desig2 = SpecimenTypeDesignation.NewInstance();
 251                 desig2.setUuid(UUID.fromString("bf357711-e752-44e9-bd3d-aef0a0bb5b91"));
 252                 name1.addTypeDesignation(desig2, true);
 253
 254                 typeDesignationDao.saveOrUpdate(desig1);
 255                 typeDesignationDao.saveOrUpdate(desig2);
 256
 257                 this.setComplete();
 258                 this.endTransaction();
 259                 this.startNewTransaction();
 260
 261                 name1 = nameDao.load(name1.getUuid());
 262                 Assert.assertNotNull(name1);
 263                 Assert.assertEquals("Name1 should have 2 type designations", 2, name1.getTypeDesignations().size());
 264
 265                 desig1 = (SpecimenTypeDesignation)typeDesignationDao.load(desig1.getUuid());
 266                 name1.removeTypeDesignation(desig1);
 267                 typeDesignationDao.saveOrUpdate(desig1);
 268
 269                 this.setComplete();
 270                 this.endTransaction();
 271                 this.startNewTransaction();
 272
 273                 name1 = nameDao.load(name1.getUuid());
 274                 Assert.assertNotNull(name1);
 275                 Assert.assertEquals("Name1 should have 1 type designation", 1, name1.getTypeDesignations().size());
 276
 277                 desig2 = (SpecimenTypeDesignation)typeDesignationDao.load(desig2.getUuid());
 278                 Assert.assertNotNull(desig2);
 279                 name1.removeTypeDesignation(desig2);
 280                 typeDesignationDao.saveOrUpdate(desig2);
 281
 282                 this.setComplete();
 283                 this.endTransaction();
 284                 this.startNewTransaction();
 285
 286                 name1 = nameDao.load(name1.getUuid());
 287                 Assert.assertNotNull(name1);
 288                 Assert.assertEquals("Name1 should have no type designations", 0, name1.getTypeDesignations().size());
 289
 290                 name2 = nameDao.load(name2.getUuid());
 291                 Assert.assertNotNull(name1);
 292                 Assert.assertEquals("Name2 should have 1 type designation", 1, name2.getTypeDesignations().size());
 293                 SpecimenTypeDesignation desig1New = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
 294                 desig1 = (SpecimenTypeDesignation)typeDesignationDao.load(desig1.getUuid());
 295                 Assert.assertSame("Desig1New should be same as desig1", desig1, desig1New);
 296
 297                 try{
 298                         typeDesignationDao.delete(desig1);
 299                         this.setComplete();
 300                         this.endTransaction();
 301                         Assert.fail("desig1 should not be deletable as it is still connected to name2");
 302                 }catch (Exception e){
 303                     //this.setComplete();
 304             this.endTransaction();
 305                         this.startNewTransaction();
 306                 }
 307                 name2 = nameDao.load(name2.getUuid());
 308                 Assert.assertNotNull(name1);
 309                 desig1 = (SpecimenTypeDesignation)typeDesignationDao.load(desig1.getUuid());
 310                 name2.removeTypeDesignation(desig1);
 311
 312                 typeDesignationDao.delete(desig1);  //now it can be deleted
 313
 314                 this.setComplete();
 315                 this.endTransaction();
 316                 this.startNewTransaction();
 317
 318                 desig2 = (SpecimenTypeDesignation)typeDesignationDao.load(desig2.getUuid());
 319                 typeDesignationDao.delete(desig2); //desig2 is already orphaned and therefore can be deleted
 320
 321                 this.setComplete();
 322                 this.endTransaction();
 323
 324 //              printDataSet(System.out, new String[]{"TaxonName","TaxonName_AUD","TypeDesignationBase","TypeDesignationBase_AUD",
 325 //                              "TaxonName_TypeDesignationBase","TaxonName_TypeDesignationBase_AUD",
 326 //                              "SpecimenOrObservationBase","SpecimenOrObservationBase_AUD",
 327 //                              "HomotypicalGroup","HomotypicalGroup_AUD"});
 328         }
 329
 330     @Override
 331     public void createTestDataSet() throws FileNotFoundException {}
 332 }