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