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 org.apache.log4j.Logger;
  16 import org.junit.Assert;
  17 import org.junit.Ignore;
  18 import org.junit.Test;
  19 import org.unitils.spring.annotation.SpringBeanByType;
  20
  21 import eu.etaxonomy.cdm.model.common.DescriptionElementSource;
  22 import eu.etaxonomy.cdm.model.common.Language;
  23 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  24 import eu.etaxonomy.cdm.model.description.Feature;
  25 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  26 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  27 import eu.etaxonomy.cdm.model.description.TextData;
  28 import eu.etaxonomy.cdm.model.name.BotanicalName;
  29 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  30 import eu.etaxonomy.cdm.model.name.NameRelationship;
  31 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  32 import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
  33 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  34 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  35 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  36 import eu.etaxonomy.cdm.model.name.NonViralName;
  37 import eu.etaxonomy.cdm.model.name.Rank;
  38 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  39 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  40 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  41 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  42 import eu.etaxonomy.cdm.model.occurrence.Specimen;
  43 import eu.etaxonomy.cdm.model.taxon.Taxon;
  44 import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
  45 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  46
  47 /**
  48  * @author a.mueller
  49  *
  50  */
  51 public class NameServiceImplTest extends CdmTransactionalIntegrationTest {
  52         private static final Logger logger = Logger.getLogger(NameServiceImplTest.class);
  53
  54         @SpringBeanByType
  55         private INameService nameService;
  56
  57         @SpringBeanByType
  58         private IOccurrenceService occurrenceService;
  59
  60         @SpringBeanByType
  61         private ITaxonService taxonService;
  62
  63         @SpringBeanByType
  64         private ITermService termService;
  65
  66
  67 /* ******************** TESTS ********************************************/
  68
  69         /**
  70          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setDao(eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao)}.
  71          */
  72         @Test
  73         public void testSetDao() {
  74 //              Assert.assertNotNull(((NameServiceImpl)nameService).dao);
  75         }
  76
  77         /**
  78          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#setVocabularyDao(eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao)}.
  79          */
  80         @Test
  81         public void testSetVocabularyDao() {
  82 //              Assert.assertNotNull(( (NameServiceImpl)nameService).vocabularyDao);
  83         }
  84
  85         /**
  86          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getNamesByName(java.lang.String)}.
  87          */
  88         @Test
  89         public void testGetNamesByName() {
  90                 logger.warn("Not yet implemented");
  91         }
  92
  93         /**
  94          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getTaxonNameByUuid(java.util.UUID)}.
  95          */
  96         @Test
  97         public void testGetTaxonNameByUuid() {
  98                 logger.warn("Not yet implemented");
  99         }
 100
 101         /**
 102          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#saveTaxonName(eu.etaxonomy.cdm.model.name.TaxonNameBase)}.
 103          */
 104         @Test
 105         public void testSaveTaxonName() {
 106                 logger.warn("Not yet implemented");
 107         }
 108
 109         /**
 110          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#saveTaxonNameAll(java.util.Collection)}.
 111          */
 112         @Test
 113         public void testSaveTaxonNameAll() {
 114                 logger.warn("Not yet implemented");
 115         }
 116
 117         /**
 118          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.name.TaxonNameBase)}.
 119          */
 120         @Test
 121         public void testRemoveTaxon() {
 122                 logger.warn("Not yet implemented");
 123         }
 124
 125         /**
 126          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getAllNames(int, int)}.
 127          */
 128         @Test
 129         public void testGetAllNames() {
 130                 logger.warn("Not yet implemented");
 131         }
 132
 133         /**
 134          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getRankVocabulary()}.
 135          */
 136         @Test
 137         @Ignore //FIXME assertSame does not work yet
 138         public void testGetRankVocabulary() {
 139                 //TODO move test to vocabulary service
 140                 OrderedTermVocabulary<Rank> rankVocabulary = nameService.getRankVocabulary();
 141                 assertNotNull(rankVocabulary);
 142                 assertEquals(66, rankVocabulary.size());
 143                 Rank highestRank = rankVocabulary.getHighestTerm();
 144                 assertEquals(Rank.EMPIRE(), highestRank);
 145                 assertEquals(Rank.DOMAIN(), rankVocabulary.getNextLowerTerm(highestRank));
 146                 assertSame(Rank.EMPIRE(), highestRank);
 147                 assertSame(Rank.DOMAIN(), rankVocabulary.getNextLowerTerm(highestRank));
 148         }
 149
 150         /**
 151          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#getTypeDesignationVocabulary()}.
 152          */
 153         @Test
 154         @Ignore  //not yet correctly implemented
 155         public void testGetTypeDesignationVocabulary() {
 156                 //TODO move test to vocabulary service
 157                 OrderedTermVocabulary<SpecimenTypeDesignationStatus> typeDesignationVocabulary =
 158                         nameService.getSpecimenTypeDesignationVocabulary();
 159                 assertNotNull(typeDesignationVocabulary);
 160                 assertEquals(20, typeDesignationVocabulary.size());
 161                 SpecimenTypeDesignationStatus highestType = typeDesignationVocabulary.getHighestTerm();
 162                 assertEquals(SpecimenTypeDesignationStatus.EPITYPE(), highestType);
 163                 assertEquals(SpecimenTypeDesignationStatus.HOLOTYPE(), typeDesignationVocabulary.getNextLowerTerm(highestType));
 164                 assertSame(SpecimenTypeDesignationStatus.EPITYPE(), highestType);
 165                 assertSame(SpecimenTypeDesignationStatus.HOLOTYPE(), typeDesignationVocabulary.getNextLowerTerm(highestType));
 166         }
 167
 168         /**
 169          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 170          */
 171         @Test
 172         public void testGenerateTitleCache() {
 173                 logger.warn("Not yet implemented");
 174         }
 175
 176         /**
 177          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 178          */
 179         @Test
 180         public void testDeleteTaxonNameBaseWithNameRelations() {
 181                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
 182
 183                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 184                 name1.setTitleCache("Name1", true);
 185                 TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 186                 nameWithBasionym.setTitleCache("nameWithBasionym", true);
 187
 188                 NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 189                 name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 190 //              nameWithBasionym.addBasionym(name1);
 191                 nameService.save(name1);
 192                 commitAndStartNewTransaction(tableNames);
 193
 194                 try {
 195                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 196                         nameService.delete(name1);
 197                         Assert.fail("Delete should throw an error as long as name relationships exist.");
 198                 } catch (Exception e) {
 199                         if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 200                                 //ok
 201                                 endTransaction();  //exception rolls back transaction!
 202                                 printDataSet(System.out, tableNames);
 203                                 startNewTransaction();
 204                         }else{
 205                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 206                         }
 207                 }
 208                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 209                 Assert.assertNotNull("Name should still be in database",name1);
 210                 nameWithBasionym = ((NameRelationship)name1.getNameRelations().iterator().next()).getToName();
 211                 nameWithBasionym.removeBasionyms();
 212                 nameService.delete(name1); //should throw now exception
 213                 commitAndStartNewTransaction(tableNames);
 214                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 215                 Assert.assertNull("Name should not be in database anymore",name1);
 216
 217         }
 218
 219
 220         /**
 221          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 222          */
 223         @Test
 224         public void testDeleteTaxonNameBaseConfiguratorWithNameRelations() {
 225                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 226
 227                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 228                 name1.setTitleCache("Name1", true);
 229                 TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 230                 nameWithBasionym.setTitleCache("nameWithBasionym", true);
 231
 232                 NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 233                 name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 234                 nameService.save(name1);
 235                 commitAndStartNewTransaction(tableNames);
 236                 NameDeletionConfigurator config = new NameDeletionConfigurator();
 237                 try {
 238                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 239                         nameService.delete(name1, config);
 240                         Assert.fail("Delete should throw an error as long as name relationships exist.");
 241                 } catch (Exception e) {
 242                         if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 243                                 //ok
 244                                 endTransaction();  //exception rolls back transaction!
 245                                 printDataSet(System.out, tableNames);
 246                                 startNewTransaction();
 247                         }else{
 248                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 249                         }
 250                 }
 251                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 252                 Assert.assertNotNull("Name should still be in database",name1);
 253
 254                 //ignore is basionym for
 255                 config.setIgnoreIsBasionymFor(true);
 256                 try {
 257                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 258                         nameService.delete(name1, config);
 259                         commitAndStartNewTransaction(tableNames);
 260                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 261                         Assert.assertNull("Name should not be in database anymore",name1);
 262                 } catch (Exception e) {
 263                         Assert.fail("Delete should not throw an error for .");
 264                 }
 265         }
 266
 267         /**
 268          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 269          */
 270         @Test
 271         public void testDeleteTaxonNameBaseConfiguratorWithNameRelationsAll() {
 272                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 273
 274                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 275                 name1.setTitleCache("Name1", true);
 276                 TaxonNameBase<?,?> nameWithBasionym = BotanicalName.NewInstance(getSpeciesRank());
 277                 nameWithBasionym.setTitleCache("nameWithBasionym", true);
 278
 279                 NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 280                 name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
 281                 nameService.save(name1);
 282                 commitAndStartNewTransaction(tableNames);
 283                 NameDeletionConfigurator config = new NameDeletionConfigurator();
 284                 try {
 285                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 286                         nameService.delete(name1, config);
 287                         Assert.fail("Delete should throw an error as long as name relationships exist.");
 288                 } catch (Exception e) {
 289                         if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 290                                 //ok
 291                                 endTransaction();  //exception rolls back transaction!
 292                                 printDataSet(System.out, tableNames);
 293                                 startNewTransaction();
 294                         }else{
 295                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 296                         }
 297                 }
 298                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 299                 Assert.assertNotNull("Name should still be in database",name1);
 300
 301                 //ignore all name relationships
 302                 config.setRemoveAllNameRelationships(true);
 303                 try {
 304                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 305                         nameService.delete(name1, config);
 306                         commitAndStartNewTransaction(tableNames);
 307                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 308                         Assert.assertNull("Name should not be in database anymore",name1);
 309                 } catch (Exception e) {
 310                         Assert.fail("Delete should not throw an error for .");
 311                 }
 312         }
 313
 314         /**
 315          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 316          */
 317         @Test
 318         public void testDeleteTaxonNameBaseConfiguratorWithHasBasionym() {
 319                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 320
 321                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 322                 name1.setTitleCache("Name1", true);
 323                 TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 324                 basionym.setTitleCache("basionym", true);
 325
 326                 NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
 327                 basionym.addRelationshipToName(name1,nameRelType , null, null, null);
 328                 nameService.save(name1);
 329                 commitAndStartNewTransaction(tableNames);
 330                 NameDeletionConfigurator config = new NameDeletionConfigurator();
 331                 config.setIgnoreHasBasionym(false);
 332                 try {
 333                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 334                         nameService.delete(name1, config);
 335                         Assert.fail("Delete should throw an error as long as name relationships exist.");
 336                 } catch (Exception e) {
 337                         if (e.getMessage().startsWith("Name can't be deleted as it is used in name relationship")){
 338                                 //ok
 339                                 endTransaction();  //exception rolls back transaction!
 340                                 printDataSet(System.out, tableNames);
 341                                 startNewTransaction();
 342                         }else{
 343                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 344                         }
 345                 }
 346                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 347                 Assert.assertNotNull("Name should still be in database",name1);
 348
 349                 //ignore has basionym
 350                 config.setIgnoreHasBasionym(true);
 351                 try {
 352                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 353                         nameService.delete(name1, config);
 354                         commitAndStartNewTransaction(tableNames);
 355                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 356                         Assert.assertNull("Name should not be in database anymore",name1);
 357                 } catch (Exception e) {
 358                         Assert.fail("Delete should not throw an error for .");
 359                 }
 360         }
 361
 362
 363         /**
 364          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 365          */
 366         @Test
 367         public void testDeleteTaxonNameBaseWithHybridRelations() {
 368                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
 369
 370                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 371                 name1.setTitleCache("Name1", true);
 372                 NonViralName<?> parent = BotanicalName.NewInstance(getSpeciesRank());
 373                 parent.setTitleCache("parent", true);
 374                 NonViralName<?> child = BotanicalName.NewInstance(getSpeciesRank());
 375                 child.setTitleCache("child", true);
 376
 377                 HybridRelationshipType relType = (HybridRelationshipType)termService.find(HybridRelationshipType.FIRST_PARENT().getUuid());
 378                 name1.addHybridParent(parent, relType, null);
 379                 nameService.save(name1);
 380                 commitAndStartNewTransaction(tableNames); //otherwise first save is rolled back with following failing delete
 381
 382                 //parent
 383                 try {
 384                         nameService.delete(name1);
 385                         Assert.fail("Delete should throw an error as long as hybrid parent exist.");
 386                 } catch (Exception e) {
 387                         if (e.getMessage().startsWith("Name can't be deleted as it is a child in")){
 388                                 //ok
 389                                 endTransaction();  //exception rolls back transaction!
 390                                 printDataSet(System.out, tableNames);
 391                                 startNewTransaction();
 392                         }else{
 393                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 394                         }
 395                 }
 396                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 397                 Assert.assertNotNull("Name should still be in database",name1);
 398                 name1.removeHybridParent(parent);
 399                 nameService.delete(name1); //should throw now exception
 400                 commitAndStartNewTransaction(tableNames);
 401                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 402                 Assert.assertNull("Name should not be in database anymore",name1);
 403
 404                 //child
 405                 name1 = BotanicalName.NewInstance(getSpeciesRank());
 406                 name1.addHybridChild(child, relType, null);
 407                 nameService.save(name1);
 408                 commitAndStartNewTransaction(tableNames);
 409
 410                 try {
 411                         nameService.delete(name1);
 412                         Assert.fail("Delete should throw an error as long as hybrid child exist.");
 413                 } catch (Exception e) {
 414                         if (e.getMessage().startsWith("Name can't be deleted as it is a parent in")){
 415                                 //ok
 416                                 endTransaction();  //exception rolls back transaction!
 417                                 startNewTransaction();
 418                         }else{
 419                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 420                         }
 421                 }
 422                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 423                 Assert.assertNotNull("Name should still be in database",name1);
 424                 name1.removeHybridChild(child);
 425                 nameService.delete(name1); //should throw now exception
 426                 commitAndStartNewTransaction(tableNames);
 427                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 428                 Assert.assertNull("Name should not be in database anymore",name1);
 429         }
 430
 431         /**
 432          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 433          */
 434         @Test
 435         public void testDeleteTaxonNameBaseInConcept() {
 436                 final String[] tableNames = new String[]{"TaxonNameBase","TaxonBase"};
 437
 438                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 439                 name1.setTitleCache("Name1", true);
 440                 TaxonNameBase<?,?> basionym = BotanicalName.NewInstance(getSpeciesRank());
 441                 basionym.setTitleCache("basionym", true);
 442
 443                 Taxon taxon = Taxon.NewInstance(name1, null);
 444                 nameService.save(name1);
 445                 taxonService.save(taxon);
 446                 commitAndStartNewTransaction(tableNames);
 447
 448                 try {
 449                         nameService.delete(name1);
 450                         Assert.fail("Delete should throw an error as long as name is used in a concept.");
 451                 } catch (Exception e) {
 452                         if (e.getMessage().startsWith("Name can't be deleted as it is used in concept")){
 453                                 //ok
 454                                 endTransaction();  //exception rolls back transaction!
 455                                 startNewTransaction();
 456                         }else{
 457                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 458                         }
 459                 }
 460                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 461                 Assert.assertNotNull("Name should still be in database",name1);
 462                 taxon = (Taxon)taxonService.find(taxon.getUuid());
 463                 Assert.assertNotNull("Taxon should still be in database",taxon);
 464                 taxon.setName(basionym);
 465                 taxonService.save(taxon);
 466                 nameService.delete(name1); //should throw now exception
 467                 commitAndStartNewTransaction(tableNames);
 468                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 469                 Assert.assertNull("Name should not be in database anymore",name1);
 470                 taxon = (Taxon)taxonService.find(taxon.getUuid());
 471                 Assert.assertNotNull("Taxon should still be in database",taxon);
 472         }
 473
 474         /**
 475          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 476          */
 477         @Test
 478         public void testDeleteTaxonNameBaseAsStoredUnder() {
 479                 final String[] tableNames = new String[]{"TaxonNameBase","SpecimenOrObservationBase"};
 480
 481                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 482                 name1.setTitleCache("Name1", true);
 483                 Specimen specimen = Specimen.NewInstance();
 484                 specimen.setStoredUnder(name1);
 485
 486                 occurrenceService.save(specimen);
 487                 nameService.save(name1);
 488                 try {
 489                         commitAndStartNewTransaction(tableNames);
 490                         nameService.delete(name1);
 491                         Assert.fail("Delete should throw an error as long as name is used for specimen#storedUnder.");
 492                 } catch (Exception e) {
 493                         if (e.getMessage().startsWith("Name can't be deleted as it is used as derivedUnit#storedUnder")){
 494                                 //ok
 495                                 endTransaction();  //exception rolls back transaction!
 496                                 startNewTransaction();
 497                         }else{
 498                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 499                         }
 500                 }
 501                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 502                 Assert.assertNotNull("Name should still be in database",name1);
 503                 specimen = (Specimen)occurrenceService.find(specimen.getUuid());
 504                 Assert.assertNotNull("Specimen should still be in database",name1);
 505                 specimen.setStoredUnder(null);
 506                 occurrenceService.saveOrUpdate(specimen);
 507                 nameService.delete(name1); //should throw now exception
 508                 commitAndStartNewTransaction(tableNames);
 509                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 510                 Assert.assertNull("Name should not be in database anymore",name1);
 511                 specimen = (Specimen)occurrenceService.find(specimen.getUuid());
 512                 Assert.assertNotNull("Specimen should still be in database",specimen);
 513
 514                 occurrenceService.delete(specimen); //this is to better run this test in the test suit
 515
 516         }
 517
 518         /**
 519          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 520          */
 521         @Test
 522         public void testDeleteTaxonNameBaseInSource() {
 523                 final String[] tableNames = new String[]{"TaxonNameBase","DescriptionBase","TaxonBase","OriginalSourceBase","DescriptionElementBase"};
 524
 525                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 526                 name1.setTitleCache("Name1", true);
 527                 TaxonNameBase<?,?> taxonName = BotanicalName.NewInstance(getSpeciesRank());
 528                 taxonName.setTitleCache("taxonName", true);
 529                 Taxon taxon = Taxon.NewInstance(taxonName, null);
 530
 531                 TaxonDescription taxonDescription = TaxonDescription.NewInstance(taxon);
 532                 Feature feature = (Feature)termService.find(Feature.DESCRIPTION().getUuid());
 533                 Language lang = (Language)termService.find(Language.DEFAULT().getUuid());
 534                 TextData textData = TextData.NewInstance("Any text", lang, null);
 535                 textData.setFeature(feature);
 536                 taxonDescription.addElement(textData);
 537                 DescriptionElementSource source = DescriptionElementSource.NewInstance(null, null, name1, "");
 538                 textData.addSource(source);
 539                 taxonService.saveOrUpdate(taxon);
 540                 nameService.save(name1);
 541                 try {
 542                         commitAndStartNewTransaction(tableNames);
 543                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 544                         nameService.delete(name1);
 545                         Assert.fail("Delete should throw an error as long as name is used in a source.");
 546                 } catch (Exception e) {
 547                         if (e.getMessage().startsWith("Name can't be deleted as it is used as descriptionElementSource#nameUsedInSource")){
 548                                 //ok
 549                                 endTransaction();  //exception rolls back transaction!
 550                                 startNewTransaction();
 551                         }else{
 552                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 553                         }
 554                 }
 555                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 556                 Assert.assertNotNull("Name should still be in database",name1);
 557                 taxon = (Taxon)taxonService.find(taxon.getUuid());
 558                 Assert.assertNotNull("Taxon should still be in database",name1);
 559                 source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 560                 source.setNameUsedInSource(null);
 561                 taxonService.saveOrUpdate(taxon);
 562                 nameService.delete(name1);  //should throw now exception
 563                 commitAndStartNewTransaction(tableNames);
 564                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 565                 Assert.assertNull("Name should not be in database anymore",name1);
 566                 taxon = (Taxon)taxonService.find(taxon.getUuid());
 567                 Assert.assertNotNull("Taxon should still be in database",taxon);
 568                 source = taxon.getDescriptions().iterator().next().getElements().iterator().next().getSources().iterator().next();
 569                 Assert.assertNull("Source should not have a nameUsedInSource anymore",source.getNameUsedInSource());
 570         }
 571
 572
 573         /**
 574          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 575          */
 576         @Test
 577         public void testDeleteTaxonNameBaseAsType() {
 578                 final String[] tableNames = new String[]{"TaxonNameBase","TypeDesignationBase","TypeDesignationBase_TaxonNameBase","TaxonNameBase_TypeDesignationBase"};
 579
 580                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 581                 name1.setTitleCache("Name used as type", true);
 582
 583                 NonViralName<?> higherName = BotanicalName.NewInstance(getGenusRank());
 584                 higherName.setTitleCache("genus name", true);
 585                 NameTypeDesignationStatus typeStatus = (NameTypeDesignationStatus)termService.find(NameTypeDesignationStatus.AUTOMATIC().getUuid());
 586                 boolean addToAllHomotypicNames = true;
 587                 higherName.addNameTypeDesignation(name1, null, null, null, typeStatus, addToAllHomotypicNames);
 588                 nameService.save(higherName);
 589                 try {
 590                         commitAndStartNewTransaction(tableNames);
 591                         name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 592                         nameService.delete(name1);
 593                         Assert.fail("Delete should throw an error as long as name is used in a source.");
 594                 } catch (Exception e) {
 595                         if (e.getMessage().startsWith("Name can't be deleted as it is used as a name type")){
 596                                 //ok
 597                                 endTransaction();  //exception rolls back transaction!
 598                                 startNewTransaction();
 599                         }else{
 600                                 Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
 601                         }
 602                 }
 603                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 604                 Assert.assertNotNull("Name should still be in database",name1);
 605                 higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 606                 higherName.removeTypeDesignation(higherName.getNameTypeDesignations().iterator().next());
 607                 nameService.delete(name1);  //should throw now exception
 608                 commitAndStartNewTransaction(tableNames);
 609                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 610                 Assert.assertNull("Name should not be in database anymore",name1);
 611                 printDataSet(System.out, tableNames);
 612                 higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
 613                 Assert.assertNotNull("Higher name should still exist in database",higherName);
 614                 Assert.assertEquals("Higher name should not have type designations anymore",0, higherName.getTypeDesignations().size());
 615         }
 616
 617
 618
 619         /**
 620          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 621          */
 622         @Test
 623         public void testDeleteTaxonNameBase() {
 624                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TypeDesignationBase_TaxonNameBase","TaxonNameBase_TypeDesignationBase"};
 625
 626                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 627                 name1.setTitleCache("Name1", true);
 628
 629                 //TaxonNameDescription
 630                 name1 = BotanicalName.NewInstance(getSpeciesRank());
 631                 TaxonNameDescription.NewInstance(name1);
 632                 nameService.save(name1);
 633                 commitAndStartNewTransaction(tableNames);
 634
 635                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 636                 nameService.delete(name1);  //should throw now exception
 637                 setComplete();
 638                 endTransaction();
 639                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 640                 Assert.assertNull("Name should not be in database anymore",name1);
 641
 642 //              printDataSet(System.out, tableNames);
 643
 644
 645                 //NomenclaturalStatus
 646                 name1 = BotanicalName.NewInstance(getSpeciesRank());
 647                 NomenclaturalStatusType nomStatusType = (NomenclaturalStatusType)termService.find(NomenclaturalStatusType.ILLEGITIMATE().getUuid());
 648                 NomenclaturalStatus status = NomenclaturalStatus.NewInstance(nomStatusType);
 649                 name1.addStatus(status);
 650                 nameService.save(name1);
 651                 commitAndStartNewTransaction(tableNames);
 652
 653                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 654                 nameService.delete(name1);  //should throw now exception
 655                 setComplete();
 656                 endTransaction();
 657 //              printDataSet(System.out, tableNames);
 658
 659
 660                 //Type Designations
 661                 name1 = BotanicalName.NewInstance(getSpeciesRank());
 662                 name1.setTitleCache("Name with type designation", true);
 663                 SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 664                 SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 665                 typeDesignation.setTypeStatus(typeStatus);
 666                 Specimen specimen = Specimen.NewInstance();
 667                 specimen.setTitleCache("Type specimen", true);
 668                 occurrenceService.save(specimen);
 669                 typeDesignation.setTypeSpecimen(specimen);
 670
 671                 name1.addTypeDesignation(typeDesignation, true);
 672                 nameService.save(name1);
 673                 commitAndStartNewTransaction(tableNames);
 674 //              printDataSet(System.out, tableNames);
 675
 676                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 677                 nameService.delete(name1);  //should throw now exception
 678                 setComplete();
 679                 endTransaction();
 680 //              printDataSet(System.out, tableNames);
 681
 682         }
 683
 684         /**
 685          * Test method for {@link eu.etaxonomy.cdm.api.service.NameServiceImpl#generateTitleCache()}.
 686          */
 687         @Test
 688         @Ignore //Mapping not yet correctly implemented
 689         public void testDeleteTaxonNameBaseWithTypeInHomotypicalGroup() {
 690                 final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TypeDesignationBase_TaxonNameBase","TaxonNameBase_TypeDesignationBase"};
 691
 692                 //Type Designations for homotypical group with > 1 names
 693                 NonViralName<?> name1 = BotanicalName.NewInstance(getSpeciesRank());
 694                 name1.setTitleCache("Name1 with type designation", true);
 695                 NonViralName<?> name2 = BotanicalName.NewInstance(getSpeciesRank());
 696                 name2.setTitleCache("Name2 with type designation", true);
 697                 name2.setHomotypicalGroup(name1.getHomotypicalGroup());
 698
 699                 Specimen specimen = Specimen.NewInstance();
 700                 specimen.setTitleCache("Type specimen 2", true);
 701                 occurrenceService.save(specimen);
 702                 SpecimenTypeDesignationStatus typeStatus = (SpecimenTypeDesignationStatus)termService.find(SpecimenTypeDesignationStatus.HOLOTYPE().getUuid());
 703
 704                 SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 705                 typeDesignation.setTypeStatus(typeStatus);
 706                 typeDesignation.setTypeSpecimen(specimen);
 707
 708                 boolean addToAllNames = true;
 709                 name1.addTypeDesignation(typeDesignation, addToAllNames);
 710                 nameService.save(name1);
 711                 commitAndStartNewTransaction(tableNames);
 712                 printDataSet(System.out, tableNames);
 713
 714                 name1 = (NonViralName<?>)nameService.find(name1.getUuid());
 715                 nameService.delete(name1);  //should throw now exception
 716                 setComplete();
 717                 endTransaction();
 718                 printDataSet(System.out, tableNames);
 719
 720         }
 721
 722         /**
 723          * @param tableNames
 724          */
 725         private void commitAndStartNewTransaction(final String[] tableNames) {
 726                 setComplete();
 727                 endTransaction();
 728 //              printDataSet(System.out, tableNames);
 729                 startNewTransaction();
 730         }
 731
 732
 733         /**
 734          * @return
 735          */
 736         private Rank getSpeciesRank() {
 737                 return (Rank)termService.find(Rank.uuidSpecies);
 738         }
 739
 740         /**
 741          * @return
 742          */
 743         private Rank getGenusRank() {
 744                 return (Rank)termService.find(Rank.uuidGenus);
 745         }
 746
 747
 748 }