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