cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/NameServiceImplTest.java

   1 /**
   2 * Copyright (C) 2009 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.api.service;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertSame;
  14
  15 import java.io.FileNotFoundException;
  16 import java.util.Set;
  17 import java.util.UUID;
  18
  19 import org.apache.log4j.Logger;
  20 import org.junit.Assert;
  21 import org.junit.Ignore;
  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.api.service.config.NameDeletionConfigurator;
  27 import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
  28 import eu.etaxonomy.cdm.model.common.CdmBase;
  29 import eu.etaxonomy.cdm.model.common.Language;
  30 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  31 import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
  32 import eu.etaxonomy.cdm.model.description.Feature;
  33 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  34 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  35 import eu.etaxonomy.cdm.model.description.TextData;
  36 import eu.etaxonomy.cdm.model.name.BotanicalName;
  37 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  38 import eu.etaxonomy.cdm.model.name.NameRelationship;
  39 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  40 import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
  41 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  42 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  43 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  44 import eu.etaxonomy.cdm.model.name.NonViralName;
  45 import eu.etaxonomy.cdm.model.name.Rank;
  46 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  47 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  48 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  49 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  50 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  51 import eu.etaxonomy.cdm.model.taxon.Taxon;
  52 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  53 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  54 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  55
  56 /**
  57  * @author a.mueller
  58  *
  59  */
  60 public class NameServiceImplTest extends CdmTransactionalIntegrationTest {
  61     private static final Logger logger = Logger.getLogger(NameServiceImplTest.class);
  62
  63     @SpringBeanByType
  64     private INameService nameService;
  65
  66     @SpringBeanByType
  67     private IOccurrenceService occurrenceService;
  68
  69     @SpringBeanByType
  70     private ITaxonService taxonService;
  71
  72     @SpringBeanByType
  73     private ITermService termService;
  74
  75
  76 /* ******************** TESTS ********************************************/
  77
  78     /**
  79      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setDao(eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao)}.
  80      */
  81     @Test
  82     public void testSetDao() {
  83 //              Assert.assertNotNull(((NameServiceImpl)nameService).dao);
  84     }
  85
  86     /**
  87      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setVocabularyDao(eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao)}.
  88      */
  89     @Test
  90     public void testSetVocabularyDao() {
  91 //              Assert.assertNotNull(( (NameServiceImpl)nameService).vocabularyDao);
  92     }
  93
  94     /**
  95      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getNamesByName(java.lang.String)}.
  96      */
  97     @Test
  98     public void testGetNamesByName() {
  99         logger.warn("Not yet implemented");
 100     }
 101
 102
 103     /**
 104      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getAllNames(int, int)}.
 105      */
 106     @Test
 107     public void testGetAllNames() {
 108         logger.warn("Not yet implemented");
 109     }
 110
 111
 112
 113     /**
 114      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 115      */
 116     @Test
 117     public void testGenerateTitleCache() {
 118         logger.warn("Not yet implemented");
 119     }
 120
 121     /**
 122      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 123      */
 124     @Test
 125     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 126     public void testDeleteTaxonNameBaseWithNameRelations() {
 127
 128         final String[] tableNames = new String[]{"USERACCOUNT", "TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
 129 //        printDataSetWithNull(System.err, true, null);
 130
 131         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 132         name1.setTitleCache("Name1", true);
 133         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 134         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 135
 136         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 137         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 138 //              nameWithBasionym.addBasionym(name1);
 139         nameService.save(name1);
 140         commitAndStartNewTransaction(tableNames);
 141
 142
 143         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 144         DeleteResult result = nameService.delete(name1);
 145         if (!result.isOk()){
 146                 Exception e = result.getExceptions().get(0);
 147                 Assert.assertEquals("The Ecxeption should be a ReferencedObjectException because it is a basionym", "Name can't be deleted as it is a basionym.", e.getMessage());
 148         } else{
 149                 Assert.fail();
 150         }
 151         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 152         Assert.assertNotNull("Name should still be in database",name1);
 153         nameWithBasionym = ((NameRelationship)name1.getNameRelations().iterator().next()).getToName();
 154         nameWithBasionym.removeBasionyms();
 155
 156         result = nameService.delete(name1); //should throw now exception
 157
 158
 159
 160         commitAndStartNewTransaction(tableNames);
 161         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 162         Assert.assertNull("Name should not be in database anymore",name1);
 163
 164     }
 165
 166
 167     /**
 168      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 169      */
 170
 171     @Test
 172     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 173     public void testDeleteTaxonNameBaseConfiguratorWithNameRelations() {
 174         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 175
 176 //        printDataSet(System.err, new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase",
 177 //                "DescriptionElementBase",
 178 //                "AGENTBASE", "USERACCOUNT", "PERMISSIONGROUP", "USERACCOUNT_PERMISSIONGROUP", "USERACCOUNT_GRANTEDAUTHORITYIMPL", "GRANTEDAUTHORITYIMPL"});
 179
 180         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 181         name1.setTitleCache("Name1", true);
 182         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 183         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 184
 185         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 186         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 187         nameService.save(name1);
 188         commitAndStartNewTransaction(tableNames);
 189         NameDeletionConfigurator config = new NameDeletionConfigurator();
 190
 191         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 192         DeleteResult result = nameService.delete(name1, config);
 193         if (result.isOk()){
 194                 Assert.fail("This should throw an error as long as name relationships exist.");
 195         }
 196
 197
 198         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 199         Assert.assertNotNull("Name should still be in database",name1);
 200
 201         //ignore is basionym for
 202         config.setIgnoreIsBasionymFor(true);
 203
 204         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 205         nameService.delete(name1,  config);
 206         commitAndStartNewTransaction(tableNames);
 207         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 208         Assert.assertNull("Name should not be in database anymore",name1);
 209
 210     }
 211
 212     /**
 213      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 214      */
 215     @Test
 216     public void testDeleteTaxonNameBaseConfiguratorWithNameRelationsAll() {
 217         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 218
 219         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 220         name1.setTitleCache("Name1", true);
 221         TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 222         nameWithBasionym.setTitleCache("nameWithBasionym", true);
 223
 224         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 225         name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 226         nameService.save(name1);
 227         commitAndStartNewTransaction(tableNames);
 228         NameDeletionConfigurator config = new NameDeletionConfigurator();
 229
 230         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 231         DeleteResult result = nameService.delete(name1, config);
 232        if (result.isOk()){
 233            Assert.fail("Delete should throw an error as long as name relationships exist.");
 234         }
 235
 236
 237         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 238         Assert.assertNotNull("Name should still be in database",name1);
 239
 240         //ignore all name relationships
 241         config.setRemoveAllNameRelationships(true);
 242
 243         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 244         result = nameService.delete(name1, config);
 245         logger.debug(result);
 246         commitAndStartNewTransaction(tableNames);
 247         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 248         Assert.assertNull("Name should not be in database anymore",name1);
 249
 250     }
 251
 252     /**
 253      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 254      */
 255     @Test
 256     public void testDeleteTaxonNameBaseConfiguratorWithHasBasionym() {
 257         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 258
 259         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 260         name1.setTitleCache("Name1", true);
 261         TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 262         basionym.setTitleCache("basionym", true);
 263
 264         NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 265         basionym.addRelationshipToName(name1,nameRelType , null, null, null);
 266         nameService.save(name1);
 267         commitAndStartNewTransaction(tableNames);
 268         NameDeletionConfigurator config = new NameDeletionConfigurator();
 269         config.setIgnoreHasBasionym(false);
 270
 271        name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 272        DeleteResult result = nameService.delete(name1, config);
 273       if (result.isOk()){
 274           Assert.fail("Delete should throw an error as long as name relationships exist.");
 275         }
 276
 277
 278         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 279         Assert.assertNotNull("Name should still be in database",name1);
 280
 281         //ignore has basionym
 282         config.setIgnoreHasBasionym(true);
 283         try {
 284             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 285             result = nameService.delete(name1, config);
 286             logger.debug(result);
 287             commitAndStartNewTransaction(tableNames);
 288             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 289             Assert.assertNull("Name should not be in database anymore",name1);
 290         } catch (Exception e) {
 291             Assert.fail("Delete should not throw an error for .");
 292         }
 293     }
 294
 295
 296     /**
 297      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 298      */
 299     @Test
 300    // @Ignore //currently does not run in suite
 301     public void testDeleteTaxonNameBaseWithHybridRelations() {
 302         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 303
 304         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 305         name1.setTitleCache("Name1", true);
 306         NonViralName<?> parent = BotanicalName.NewInstance(getSpeciesRank());
 307         parent.setTitleCache("parent", true);
 308         NonViralName<?> child = BotanicalName.NewInstance(getSpeciesRank());
 309         child.setTitleCache("child", true);
 310
 311         HybridRelationshipType relType = (HybridRelationshipType)termService.find(HybridRelationshipType.FIRST_PARENT().getUuid());
 312         name1.addHybridParent(parent, relType, null);
 313         nameService.save(name1);
 314         commitAndStartNewTransaction(tableNames); //otherwise first save is rolled back with following failing delete
 315         Assert.assertEquals("'Parent' should be a parent in a hybrid relation.", 1,parent.getHybridParentRelations().size());
 316 //              printDataSet(System.out, tableNames);
 317
 318         //parent
 319
 320          name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 321          DeleteResult result = nameService.delete(name1);
 322          if (result.isError()){
 323             Assert.fail("Delete should throw NO exception when deleting a hybrid child: " + result.getExceptions().get(0).getMessage());
 324         }
 325         commitAndStartNewTransaction(tableNames);
 326         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 327         Assert.assertNull("Name should not be in database anymore",name1);
 328         parent = (NonViralName<?>)nameService.find(parent.getUuid());
 329         Assert.assertEquals("'Parent' should not be a parent anymore.", 0,parent.getHybridParentRelations().size());
 330
 331         //child
 332         name1 = BotanicalName.NewInstance(getSpeciesRank());
 333         name1.addHybridChild(child, relType, null);
 334         nameService.save(name1);
 335         commitAndStartNewTransaction(tableNames);
 336
 337
 338         result = nameService.delete(name1);
 339         if (result.isOk()){
 340             Assert.fail("Delete should throw an error as long as hybrid child exist.");
 341         }
 342         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 343         Assert.assertNotNull("Name should still be in database",name1);
 344         name1.removeHybridChild(child);
 345
 346         result = nameService.delete(name1); //should throw now exception
 347         if (result.isError()){
 348                 Assert.fail("Delete should throw NO exception when deleting a hybrid child: " +result.getExceptions().get(0).getMessage());
 349         }
 350
 351         commitAndStartNewTransaction(tableNames);
 352         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 353         Assert.assertNull("Name should not be in database anymore",name1);
 354     }
 355
 356     /**
 357      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 358      */
 359     @Test
 360     public void testDeleteTaxonNameBaseInConcept() {
 361         final String[] tableNames = new String[]{"TaxonNameBase","TaxonBase"};
 362
 363         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 364         name1.setTitleCache("Name1", true);
 365         TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 366         basionym.setTitleCache("basionym", true);
 367
 368         Taxon taxon = Taxon.NewInstance(name1, null);
 369         nameService.save(name1);
 370         taxonService.save(taxon);
 371         commitAndStartNewTransaction(tableNames);
 372
 373
 374         DeleteResult result = nameService.delete(name1);
 375
 376         if (result.isOk()){
 377                 Assert.fail("Delete should throw an error as long as name is used in a concept.");
 378         }
 379         TaxonNameBase nameBase =nameService.find(name1.getUuid());
 380         Assert.assertNotNull("Name should still be in database",nameBase);
 381         TaxonBase taxonBase = taxonService.find(taxon.getUuid());
 382         Assert.assertNotNull("Taxon should still be in database",taxonBase);
 383         taxon = (Taxon)taxonBase;
 384         taxon.setName(basionym);
 385         taxonService.save(taxon);
 386         nameBase =nameService.find(name1.getUuid());
 387
 388
 389
 390
 391         result = nameService.delete(nameBase); //should throw no exception
 392         if (result.isError()){
 393                 Assert.fail("Delete should throw NO error ");
 394         }
 395         commitAndStartNewTransaction(tableNames);
 396         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 397         Assert.assertNull("Name should still be in database",name1);
 398         taxon = (Taxon)taxonService.find(taxon.getUuid());
 399         Assert.assertNotNull("Taxon should still be in database",taxon);
 400     }
 401
 402     /**
 403      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 404      */
 405     @Test
 406     public void testDeleteTaxonNameBaseAsStoredUnder() {
 407         final String[] tableNames = new String[]{"TaxonNameBase","SpecimenOrObservationBase"};
 408
 409         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 410         name1.setTitleCache("Name1", true);
 411         DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
 412         specimen.setStoredUnder(name1);
 413
 414         occurrenceService.save(specimen);
 415         UUID uuidName1 = nameService.save(name1);
 416
 417         commitAndStartNewTransaction(tableNames);
 418         DeleteResult result = nameService.delete(name1);
 419         if (result.isOk()){
 420            Assert.fail("This should throw an error because name is used for specimen#storedUnder.");
 421         }
 422          commitAndStartNewTransaction(tableNames);
 423
 424         name1 = (NonViralName<?>)nameService.find(uuidName1);
 425         Assert.assertNotNull("Name should still be in database",name1);
 426         specimen = (DerivedUnit)occurrenceService.find(specimen.getUuid());
 427         Assert.assertNotNull("Specimen should still be in database",name1);
 428         specimen.setStoredUnder(null);
 429         occurrenceService.saveOrUpdate(specimen);
 430
 431         nameService.delete(name1); //should throw no exception
 432
 433
 434         name1 = (NonViralName<?>)nameService.find(uuidName1);
 435         Assert.assertNull("Name should not be in database anymore",name1);
 436         specimen = (DerivedUnit)occurrenceService.find(specimen.getUuid());
 437         Assert.assertNotNull("Specimen should still be in database",specimen);
 438
 439                 occurrenceService.delete(specimen); //this is to better run this test in the test suit
 440
 441     }
 442
 443     /**
 444      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 445      */
 446     @Test
 447     @Ignore //currently does not run in suite
 448     public void testDeleteTaxonNameBaseInSource() {
 449         final String[] tableNames = new String[]{"TaxonNameBase","DescriptionBase","TaxonBase","OriginalSourceBase","DescriptionElementBase"};
 450
 451         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 452         name1.setTitleCache("Name1", true);
 453         TaxonNameBase<?,?> taxonName = BotanicalName.NewInstance(getSpeciesRank());
 454         taxonName.setTitleCache("taxonName", true);
 455         Taxon taxon = Taxon.NewInstance(taxonName, null);
 456
 457         TaxonDescription taxonDescription = TaxonDescription.NewInstance(taxon);
 458         Feature feature = (Feature)termService.find(Feature.DESCRIPTION().getUuid());
 459         Language lang = (Language)termService.find(Language.DEFAULT().getUuid());
 460         TextData textData = TextData.NewInstance("Any text", lang, null);
 461         textData.setFeature(feature);
 462         taxonDescription.addElement(textData);
 463         DescriptionElementSource source = DescriptionElementSource.NewPrimarySourceInstance(null, null, name1, "");
 464         textData.addSource(source);
 465         taxonService.saveOrUpdate(taxon);
 466         nameService.save(name1);
 467         try {
 468             commitAndStartNewTransaction(tableNames);
 469             name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 470             nameService.delete(name1);
 471             Assert.fail("Delete should throw an error as long as name is used in a source.");
 472         } catch (Exception e) {
 473             if (e.getMessage().contains("Name can't be deleted as it is used as descriptionElementSource#nameUsedInSource")){
 474                 //ok
 475                 endTransaction();  //exception rolls back transaction!
 476                 startNewTransaction();
 477             }else{
 478                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 479             }
 480         }
 481         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 482         Assert.assertNotNull("Name should still be in database",name1);
 483         taxon = (Taxon)taxonService.find(taxon.getUuid());
 484         Assert.assertNotNull("Taxon should still be in database",name1);
 485         source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 486         source.setNameUsedInSource(null);
 487         taxonService.saveOrUpdate(taxon);
 488
 489         nameService.delete(name1);  //should throw now exception
 490
 491         commitAndStartNewTransaction(tableNames);
 492         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 493         Assert.assertNull("Name should not be in database anymore",name1);
 494         taxon = (Taxon)taxonService.find(taxon.getUuid());
 495         Assert.assertNotNull("Taxon should still be in database",taxon);
 496         source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 497         Assert.assertNull("Source should not have a nameUsedInSource anymore",source.getNameUsedInSource());
 498     }
 499
 500
 501     /**
 502      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 503      */
 504     @Test
 505
 506     public void testDeleteTaxonNameBaseAsType() {
 507         final String[] tableNames = new String[]{"TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 508
 509         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 510         name1.setTitleCache("Name used as type", true);
 511
 512         NonViralName<?> higherName = BotanicalName.NewInstance(getGenusRank());
 513         higherName.setTitleCache("genus name", true);
 514         NameTypeDesignationStatus typeStatus = (NameTypeDesignationStatus)termService.find(NameTypeDesignationStatus.AUTOMATIC().getUuid());
 515         boolean addToAllHomotypicNames = true;
 516         higherName.addNameTypeDesignation(name1, null, null, null, typeStatus, addToAllHomotypicNames);
 517         nameService.save(higherName);
 518
 519        commitAndStartNewTransaction(tableNames);
 520        name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 521        DeleteResult result = nameService.delete(name1);
 522        if (result.isOk()){
 523            Assert.fail("This should throw an error because name is used in a type designation.");
 524         }
 525
 526         commitAndStartNewTransaction(tableNames);
 527         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 528         Assert.assertNotNull("Name should still be in database",name1);
 529         higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 530         higherName.getNameTypeDesignations().iterator().next().removeType();  //keeps the designation but removes the name from it
 531 //              nameService.deleteTypeDesignation(higherName,commitAndStartNewTransaction(tableNames) );  //deletes the complete designation  //both options can be used
 532
 533         nameService.delete(name1);  //should throw now exception
 534
 535         commitAndStartNewTransaction(tableNames);
 536         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 537         Assert.assertNull("Name should not be in database anymore",name1);
 538         higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 539         Assert.assertNotNull("Higher name should still exist in database",higherName);
 540         Assert.assertEquals("Higher name should not have type designations anymore",1, higherName.getTypeDesignations().size());
 541     }
 542
 543
 544
 545     /**
 546      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 547      */
 548     @Test
 549
 550     public void testDeleteTaxonNameBase() {
 551         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 552
 553         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 554         name1.setTitleCache("Name1", true);
 555
 556         //TaxonNameDescription
 557         name1 = BotanicalName.NewInstance(getSpeciesRank());
 558         TaxonNameDescription.NewInstance(name1);
 559         nameService.saveOrUpdate(name1);
 560         commitAndStartNewTransaction(tableNames);
 561
 562         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 563         DeleteResult result = nameService.delete(name1);//should throw now exception
 564
 565         setComplete();
 566         endTransaction();
 567         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 568         Assert.assertNull("Name should not be in database anymore",name1);
 569
 570 //              printDataSet(System.out, tableNames);
 571
 572
 573         //NomenclaturalStatus
 574         name1 = BotanicalName.NewInstance(getSpeciesRank());
 575         NomenclaturalStatusType nomStatusType = (NomenclaturalStatusType)termService.find(NomenclaturalStatusType.ILLEGITIMATE().getUuid());
 576         NomenclaturalStatus status = NomenclaturalStatus.NewInstance(nomStatusType);
 577         name1.addStatus(status);
 578         nameService.saveOrUpdate(name1);
 579         commitAndStartNewTransaction(tableNames);
 580
 581         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 582
 583         nameService.delete(name1);  //should throw now exception
 584         if (!result.isOk()){
 585                 Assert.fail();
 586         }
 587         setComplete();
 588         endTransaction();
 589 //              printDataSet(System.out, tableNames);
 590
 591
 592         //Type Designations
 593         name1 = BotanicalName.NewInstance(getSpeciesRank());
 594         name1.setTitleCache("Name with type designation", true);
 595         SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 596         SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 597         typeDesignation.setTypeStatus(typeStatus);
 598         DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
 599         specimen.setTitleCache("Type specimen", true);
 600         occurrenceService.save(specimen);
 601         typeDesignation.setTypeSpecimen(specimen);
 602
 603         name1.addTypeDesignation(typeDesignation, true);
 604         nameService.save(name1);
 605         commitAndStartNewTransaction(tableNames);
 606 //              printDataSet(System.out, tableNames);
 607
 608         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 609
 610         result = nameService.delete(name1);  //should throw now exception
 611         if (!result.isOk()){
 612                 Assert.fail();
 613         }
 614         setComplete();
 615         endTransaction();
 616 //              printDataSet(System.out, tableNames);
 617
 618     }
 619
 620     /**
 621      * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 622      */
 623     @Test
 624
 625     public void testDeleteTaxonNameBaseWithTypeInHomotypicalGroup() {
 626         final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
 627
 628         //Type Designations for homotypical group with > 1 names
 629         NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 630         name1.setTitleCache("Name1 with type designation", true);
 631         NonViralName<?> name2 = BotanicalName.NewInstance(getSpeciesRank());
 632         name2.setTitleCache("Name2 with type designation", true);
 633         name2.setHomotypicalGroup(name1.getHomotypicalGroup());
 634
 635         DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
 636         specimen.setTitleCache("Type specimen 2", true);
 637         occurrenceService.save(specimen);
 638         SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 639
 640         SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 641         typeDesignation.setTypeStatus(typeStatus);
 642         typeDesignation.setTypeSpecimen(specimen);
 643
 644         boolean addToAllNames = true;
 645         name1.addTypeDesignation(typeDesignation, addToAllNames);
 646         nameService.saveOrUpdate(name1);
 647         commitAndStartNewTransaction(tableNames);
 648
 649         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 650
 651                 nameService.delete(name1);  //should throw now exception
 652
 653         setComplete();
 654         endTransaction();
 655 //              printDataSet(System.out, tableNames);
 656
 657     }
 658
 659     @Test
 660     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 661     public void testDeleteTypeDesignation() {
 662         final String[] tableNames = new String[]{
 663                 "TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase",
 664                 "SpecimenOrObservationBase"};
 665
 666 //              BotanicalName name1 = BotanicalName.NewInstance(getSpeciesRank());
 667 //              name1.setTitleCache("Name1");
 668 //              name1.setUuid(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 669 //
 670 //              BotanicalName name2 = BotanicalName.NewInstance(getSpeciesRank());
 671 //              name2.setTitleCache("Name2");
 672 //              name2.setUuid(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 673 //
 674 //              BotanicalName name3 = BotanicalName.NewInstance(getGenusRank());
 675 //              name3.setTitleCache("Name3");
 676 //              name3.setUuid(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 677 //
 678 //
 679 //              SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
 680 //              desig1.setUuid(UUID.fromString("1357c307-00c3-499c-8e20-0849d4706125"));
 681 //              name1.addTypeDesignation(desig1, true);
 682 //              name2.addTypeDesignation(desig1, true);
 683 //
 684 //              SpecimenTypeDesignation desig2 = SpecimenTypeDesignation.NewInstance();
 685 //              desig2.setUuid(UUID.fromString("9bbda70b-7272-4e65-a807-852a3f2eba63"));
 686 //              name1.addTypeDesignation(desig2, true);
 687 //
 688 //              Specimen specimen1 = Specimen.NewInstance();
 689 //              Fossil specimen2 = Fossil.NewInstance();
 690 //
 691 //              desig1.setTypeSpecimen(specimen1);
 692 //              desig2.setTypeSpecimen(specimen2);
 693 //
 694 //              NameTypeDesignation nameDesig = NameTypeDesignation.NewInstance();
 695 //              nameDesig.setTypeName(name1);
 696 //              name3.addTypeDesignation(nameDesig, true);
 697 //
 698 //              nameService.save(name1);
 699 //              nameService.save(name2);
 700 //              nameService.save(name3);
 701 //
 702 //              commitAndStartNewTransaction(tableNames);
 703 //
 704 //              printDataSet(System.out, tableNames);
 705 //
 706
 707
 708         TaxonNameBase name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 709         TaxonNameBase name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 710         TaxonNameBase name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 711         DerivedUnit specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 712         DerivedUnit fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 713
 714         Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
 715         Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
 716         Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
 717
 718         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 719         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 720         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 721         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 722         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 723
 724         nameService.deleteTypeDesignation(null, null);
 725
 726         commitAndStartNewTransaction(tableNames);
 727
 728         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 729         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 730         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 731         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 732         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 733
 734         desigs1 = name1.getTypeDesignations();
 735         desigs2 = name2.getTypeDesignations();
 736         desigs3 = name3.getTypeDesignations();
 737         //nothing should be deleted
 738         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 739         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 740         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 741         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 742         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 743
 744         nameService.deleteTypeDesignation(name1, null);
 745
 746         commitAndStartNewTransaction(tableNames);
 747
 748         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 749         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 750         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 751         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 752         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 753
 754         desigs1 = name1.getTypeDesignations();
 755         desigs2 = name2.getTypeDesignations();
 756         desigs3 = name3.getTypeDesignations();
 757         //only the types of name1 should be deleted
 758         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 759         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 760         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 761         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 762         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 763
 764         SpecimenTypeDesignation desig2 = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
 765         nameService.deleteTypeDesignation(name2, desig2);
 766
 767         commitAndStartNewTransaction(tableNames);
 768
 769         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 770         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 771         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 772         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 773         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 774
 775         desigs1 = name1.getTypeDesignations();
 776         desigs2 = name2.getTypeDesignations();
 777         desigs3 = name3.getTypeDesignations();
 778
 779         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 780         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 781         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 782         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 783         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 784
 785         NameTypeDesignation desig3 = (NameTypeDesignation)name3.getTypeDesignations().iterator().next();
 786         name3.addTypeDesignation(SpecimenTypeDesignation.NewInstance(), false);
 787         this.nameService.update(name3);
 788
 789         this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 790         desigs3 = name3.getTypeDesignations();
 791         Assert.assertEquals("name3 should have 2 type designations", 2, desigs3.size());
 792
 793         nameService.deleteTypeDesignation(name3, desig3);
 794         commitAndStartNewTransaction(tableNames);
 795
 796
 797         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 798         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 799         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 800         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 801         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 802
 803         desigs1 = name1.getTypeDesignations();
 804         desigs2 = name2.getTypeDesignations();
 805         desigs3 = name3.getTypeDesignations();
 806
 807         Assert.assertEquals("name1 should have 0 type designations", 0, desigs1.size());
 808         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 809         Assert.assertEquals("name3 should have 0 type designations", 1, desigs3.size());
 810         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 811         Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
 812
 813     }
 814
 815     @Test
 816     @DataSet
 817     public void testDeleteTypeDesignationAllNames() {
 818         final String[] tableNames = new String[]{
 819                 "TaxonNameBase","TypeDesignationBase",
 820                 "TaxonNameBase_TypeDesignationBase","SpecimenOrObservationBase"};
 821
 822
 823         TaxonNameBase name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 824         TaxonNameBase name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 825         TaxonNameBase name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 826         DerivedUnit specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 827         DerivedUnit fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 828
 829         Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
 830         Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
 831         Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
 832
 833         Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
 834         Assert.assertEquals("name2 should have 1 type designations", 1, desigs2.size());
 835         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 836         Assert.assertEquals("Specimen1 should be used in 1 type designation", 1, specimen1.getSpecimenTypeDesignations().size());
 837         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 838
 839         SpecimenTypeDesignation desig2 = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
 840
 841         nameService.deleteTypeDesignation(null, desig2);
 842
 843         commitAndStartNewTransaction(tableNames);
 844
 845         name1 =  this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
 846         name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
 847         name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
 848         specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
 849         fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
 850
 851         desigs1 = name1.getTypeDesignations();
 852         desigs2 = name2.getTypeDesignations();
 853         desigs3 = name3.getTypeDesignations();
 854
 855         Assert.assertEquals("name1 should have 1 type designations", 1, desigs1.size());
 856         Assert.assertEquals("name2 should have 0 type designations", 0, desigs2.size());
 857         Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
 858         Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
 859         Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
 860
 861     }
 862
 863     /**
 864      * @return
 865      */
 866     private Rank getSpeciesRank() {
 867         return (Rank)termService.find(Rank.uuidSpecies);
 868     }
 869
 870     /**
 871      * @return
 872      */
 873     private Rank getGenusRank() {
 874         return (Rank)termService.find(Rank.uuidGenus);
 875     }
 876
 877     /* (non-Javadoc)
 878      * @see eu.etaxonomy.cdm.test.integration.CdmIntegrationTest#createTestData()
 879      */
 880     @Override
 881     public void createTestDataSet() throws FileNotFoundException {
 882         // TODO Auto-generated method stub
 883
 884     }
 885
 886
 887 }