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

   1 /**
   2  * Copyright (C) 2014 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.assertFalse;
  13 import static org.junit.Assert.assertNotEquals;
  14 import static org.junit.Assert.assertNotNull;
  15 import static org.junit.Assert.assertNull;
  16 import static org.junit.Assert.assertTrue;
  17
  18 import java.io.FileNotFoundException;
  19 import java.util.Collection;
  20 import java.util.Collections;
  21 import java.util.List;
  22 import java.util.Set;
  23 import java.util.UUID;
  24 import java.util.stream.Collectors;
  25
  26 import org.apache.log4j.Logger;
  27 import org.junit.Test;
  28 import org.unitils.dbunit.annotation.DataSet;
  29 import org.unitils.spring.annotation.SpringBeanByType;
  30
  31 import eu.etaxonomy.cdm.api.service.config.FindOccurrencesConfigurator;
  32 import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
  33 import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
  34 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  35 import eu.etaxonomy.cdm.model.agent.Institution;
  36 import eu.etaxonomy.cdm.model.agent.Person;
  37 import eu.etaxonomy.cdm.model.common.CdmBase;
  38 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  39 import eu.etaxonomy.cdm.model.common.Identifier;
  40 import eu.etaxonomy.cdm.model.common.TimePeriod;
  41 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  42 import eu.etaxonomy.cdm.model.description.Feature;
  43 import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
  44 import eu.etaxonomy.cdm.model.description.SpecimenDescription;
  45 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  46 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  47 import eu.etaxonomy.cdm.model.molecular.Sequence;
  48 import eu.etaxonomy.cdm.model.name.IBotanicalName;
  49 import eu.etaxonomy.cdm.model.name.Rank;
  50 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  51 import eu.etaxonomy.cdm.model.name.TaxonName;
  52 import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
  53 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  54 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  55 import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
  56 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  57 import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
  58 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  59 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  60 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
  61 import eu.etaxonomy.cdm.model.reference.Reference;
  62 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  63 import eu.etaxonomy.cdm.model.taxon.Classification;
  64 import eu.etaxonomy.cdm.model.taxon.Synonym;
  65 import eu.etaxonomy.cdm.model.taxon.SynonymType;
  66 import eu.etaxonomy.cdm.model.taxon.Taxon;
  67 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  68 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  69 import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;
  70 import eu.etaxonomy.cdm.persistence.query.AssignmentStatus;
  71 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  72 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  73
  74 /**
  75  * @author pplitzner
  76  * @since 31.03.2014
  77  *
  78  */
  79 public class OccurrenceServiceTest extends CdmTransactionalIntegrationTest {
  80
  81     @SuppressWarnings("unused")
  82     private static final Logger logger = Logger.getLogger(OccurrenceServiceTest.class);
  83
  84     @SpringBeanByType
  85     private IOccurrenceService occurrenceService;
  86
  87     @SpringBeanByType
  88     private ISequenceService sequenceService;
  89
  90     @SpringBeanByType
  91     private ITaxonService taxonService;
  92
  93     @SpringBeanByType
  94     private ITaxonNodeService taxonNodeService;
  95
  96     @SpringBeanByType
  97     private IClassificationService classificationService;
  98
  99     @SpringBeanByType
 100     private INameService nameService;
 101
 102     @SpringBeanByType
 103     private ITermService termService;
 104
 105     @SpringBeanByType
 106     private IDescriptionService descriptionService;
 107
 108     private Reference getReference() {
 109         Reference result = ReferenceFactory.newGeneric();
 110         result.setTitle("some generic reference");
 111         return result;
 112     }
 113
 114     private Taxon getTaxon() {
 115         Reference sec = getReference();
 116         TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
 117         Taxon taxon = Taxon.NewInstance(name, sec);
 118         return taxon;
 119
 120     }
 121
 122     @Test
 123     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurenceServiceTest.move.xml")
 124     public void testMoveDerivate() {
 125         DerivedUnit specimenA = (DerivedUnit) occurrenceService.load(UUID
 126                 .fromString("35cfb0b3-588d-4eee-9db6-ac9caa44e39a"));
 127         DerivedUnit specimenB = (DerivedUnit) occurrenceService.load(UUID
 128                 .fromString("09496534-efd0-44c8-b1ce-01a34a8a0229"));
 129         DerivedUnit dnaSample = (DnaSample) occurrenceService.load(UUID
 130                 .fromString("5995f852-0e78-405c-b849-d923bd6781d9"));
 131
 132         occurrenceService.saveOrUpdate(specimenA);
 133         occurrenceService.saveOrUpdate(specimenB);
 134         occurrenceService.saveOrUpdate(dnaSample);
 135
 136         Person derivationActor = Person.NewTitledInstance("Derivation Actor");
 137         String derivationDescription = "Derivation Description";
 138         Institution derivationInstitution = Institution.NewInstance();
 139         TimePeriod derivationTimePeriod = TimePeriod.NewInstance(2015);
 140
 141         DerivationEvent originalDerivedFromEvent = DerivationEvent.NewSimpleInstance(specimenA, dnaSample,
 142                 DerivationEventType.DNA_EXTRACTION());
 143
 144         originalDerivedFromEvent.setActor(derivationActor);
 145         originalDerivedFromEvent.setDescription(derivationDescription);
 146         originalDerivedFromEvent.setInstitution(derivationInstitution);
 147         originalDerivedFromEvent.setTimeperiod(derivationTimePeriod);
 148
 149         occurrenceService.moveDerivate(specimenA, specimenB, dnaSample);
 150         assertTrue("DerivationEvent not removed from source!", specimenA.getDerivationEvents().isEmpty());
 151         assertEquals("DerivationEvent not moved to source!", 1, specimenB.getDerivationEvents().size());
 152
 153         DerivationEvent derivationEvent = specimenB.getDerivationEvents().iterator().next();
 154         assertEquals("Moved DerivationEvent not of same type!", DerivationEventType.DNA_EXTRACTION(),
 155                 derivationEvent.getType());
 156         assertEquals(derivationActor, derivationEvent.getActor());
 157         assertEquals(derivationDescription, derivationEvent.getDescription());
 158         assertEquals(derivationInstitution, derivationEvent.getInstitution());
 159         assertEquals(derivationTimePeriod, derivationEvent.getTimeperiod());
 160         assertEquals(DerivationEventType.DNA_EXTRACTION(), derivationEvent.getType());
 161
 162         assertEquals("Wrong number of derivation originals!", 1, derivationEvent.getOriginals().size());
 163         SpecimenOrObservationBase<?> newOriginal = derivationEvent.getOriginals().iterator().next();
 164         assertEquals("Target of moved object not correct", specimenB, newOriginal);
 165         assertEquals("Wrong number of derivatives!", 1, derivationEvent.getDerivatives().size());
 166
 167         DerivedUnit movedDerivate = derivationEvent.getDerivatives().iterator().next();
 168         assertEquals("Moved derivate has wrong type", SpecimenOrObservationType.DnaSample,
 169                 movedDerivate.getRecordBasis());
 170         assertNotEquals("DerivationEvent 'derivedFrom' has not been changed after moving", originalDerivedFromEvent,
 171                 movedDerivate.getDerivedFrom());
 172
 173     }
 174
 175     @Test
 176     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "../../database/BlankDataSet.xml")
 177     public void testMoveDerivateNoParent() {
 178         DerivedUnit derivedUnit = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
 179         FieldUnit fieldUnit = FieldUnit.NewInstance();
 180
 181         occurrenceService.saveOrUpdate(fieldUnit);
 182         occurrenceService.saveOrUpdate(derivedUnit);
 183
 184         assertEquals("DerivationEvent not moved to source!", 0, fieldUnit.getDerivationEvents().size());
 185         occurrenceService.moveDerivate(null, fieldUnit, derivedUnit);
 186         assertEquals("DerivationEvent not moved to source!", 1, fieldUnit.getDerivationEvents().size());
 187
 188         DerivationEvent derivationEvent = fieldUnit.getDerivationEvents().iterator().next();
 189         assertNull(derivationEvent.getType());
 190
 191         assertEquals("Wrong number of derivation originals!", 1, derivationEvent.getOriginals().size());
 192         SpecimenOrObservationBase<?> newOriginal = derivationEvent.getOriginals().iterator().next();
 193         assertEquals("Target of moved object not correct", fieldUnit, newOriginal);
 194         assertEquals("Wrong number of derivatives!", 1, derivationEvent.getDerivatives().size());
 195     }
 196
 197     @Test
 198     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurenceServiceTest.move.xml")
 199     public void testMoveSequence() {
 200         DnaSample dnaSampleA = (DnaSample) occurrenceService.load(UUID
 201                 .fromString("5995f852-0e78-405c-b849-d923bd6781d9"));
 202         DnaSample dnaSampleB = (DnaSample) occurrenceService.load(UUID
 203                 .fromString("85fccc2f-c796-46b3-b2fc-6c9a4d68cfda"));
 204         String consensusSequence = "ATTCG";
 205         Sequence sequence = sequenceService.load(UUID.fromString("6da4f378-9861-4338-861b-7b8073763e7a"));
 206
 207         occurrenceService.saveOrUpdate(dnaSampleA);
 208         occurrenceService.saveOrUpdate(dnaSampleB);
 209         sequenceService.saveOrUpdate(sequence);
 210
 211         dnaSampleA.addSequence(sequence);
 212
 213         occurrenceService.moveSequence(dnaSampleA, dnaSampleB, sequence);
 214         assertEquals("Number of sequences is wrong", 0, dnaSampleA.getSequences().size());
 215         assertEquals("Number of sequences is wrong", 1, dnaSampleB.getSequences().size());
 216         Sequence next = dnaSampleB.getSequences().iterator().next();
 217         assertEquals("Sequences are not equals", sequence, next);
 218         assertEquals("Sequences are not equals", consensusSequence, next.getSequenceString());
 219     }
 220
 221     @Test
 222     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testDeleteIndividualAssociatedAndTypeSpecimen.xml")
 223     public void testDeleteIndividualAssociatedAndTypeSpecimen() {
 224         final UUID taxonDEscriptionUuid = UUID.fromString("a87a893e-2ea8-427d-a26b-dbd2515d6b8a");
 225         final UUID botanicalNameUuid = UUID.fromString("a604774e-d66a-4d47-b9d1-d0e38a8c787a");
 226         final UUID fieldUnitUuid = UUID.fromString("67e81ca8-ff91-4df6-bf48-e4600c7f15a2");
 227         final UUID derivedUnitUuid = UUID.fromString("d229713b-0123-4f15-bffc-76ae45c37564");
 228
 229         // //how the XML was generated
 230         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 231         // fieldUnit.setUuid(fieldUnitUuid);
 232         // //sub derivates (DerivedUnit, DnaSample)
 233         // DerivedUnit derivedUnit =
 234         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 235         // derivedUnit.setUuid(derivedUnitUuid);
 236         //
 237         // //derivation events
 238         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 239         // DerivationEventType.ACCESSIONING());
 240         //
 241         // occurrenceService.save(fieldUnit);
 242         // occurrenceService.save(derivedUnit);
 243         //
 244         // //create name with type specimen
 245         // BotanicalName name =
 246         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 247         // name.setUuid(BOTANICAL_NAME_UUID);
 248         // SpecimenTypeDesignation typeDesignation =
 249         // SpecimenTypeDesignation.NewInstance();
 250         // typeDesignation.setTypeSpecimen(derivedUnit);
 251         // //add type designation to name
 252         // name.addTypeDesignation(typeDesignation, false);
 253         //
 254         // // create taxon with name and two taxon descriptions (one with
 255         // // IndividualsAssociations and a "described" voucher specimen, and an
 256         // // empty one)
 257         // Taxon taxon = Taxon.NewInstance(name, null);
 258         // taxon.setUuid(taxonUuid);
 259         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 260         // taxonDescription.setUuid(TAXON_DESCRIPTION_UUID);
 261         // //add voucher
 262         // taxonDescription.addElement(IndividualsAssociation.NewInstance(fieldUnit));
 263         // taxon.addDescription(taxonDescription);
 264         // //add another taxon description to taxon which is not associated with
 265         // a specimen thus should not be taken into account
 266         // taxon.addDescription(TaxonDescription.NewInstance());
 267         // taxonService.saveOrUpdate(taxon);
 268         //
 269         //
 270         // commitAndStartNewTransaction(null);
 271         //
 272         // setComplete();
 273         // endTransaction();
 274         //
 275         //
 276         // try {
 277         // writeDbUnitDataSetFile(new String[] {
 278         // "SpecimenOrObservationBase",
 279         // "SpecimenOrObservationBase_DerivationEvent",
 280         // "DerivationEvent",
 281         // "Sequence",
 282         // "Sequence_SingleRead",
 283         // "SingleRead",
 284         // "AmplificationResult",
 285         // "DescriptionElementBase",
 286         // "DescriptionBase",
 287         // "TaxonBase",
 288         // "TypeDesignationBase",
 289         // "TaxonName",
 290         // "TaxonName_TypeDesignationBase",
 291         // "HomotypicalGroup"
 292         // }, "testDeleteIndividualAssociatedAndTypeSpecimen");
 293         // } catch (FileNotFoundException e) {
 294         // e.printStackTrace();
 295         // }
 296
 297         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 298         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 299         IBotanicalName name = nameService.load(botanicalNameUuid);
 300         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDEscriptionUuid);
 301         // check initial state (IndividualsAssociation)
 302         DescriptionElementBase descriptionElement = taxonDescription.getElements().iterator().next();
 303         assertTrue("wrong type of description element", descriptionElement.isInstanceOf(IndividualsAssociation.class));
 304         assertEquals("associated specimen is incorrect", associatedFieldUnit,
 305                 ((IndividualsAssociation) descriptionElement).getAssociatedSpecimenOrObservation());
 306         // check initial state (Type Designation)
 307         Set<TypeDesignationBase> typeDesignations = name.getTypeDesignations();
 308         TypeDesignationBase<?> typeDesignation = typeDesignations.iterator().next();
 309         assertTrue("wrong type of type designation", typeDesignation.isInstanceOf(SpecimenTypeDesignation.class));
 310         assertEquals("type specimen is incorrect", typeSpecimen,
 311                 ((SpecimenTypeDesignation) typeDesignation).getTypeSpecimen());
 312
 313         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 314         // delete type specimen from type designation
 315         config.setDeleteFromTypeDesignation(true);
 316         occurrenceService.delete(typeSpecimen, config);
 317         assertTrue(((SpecimenTypeDesignation) typeDesignation).getTypeSpecimen() == null);
 318
 319         // delete associated field unit from IndividualsAssociation
 320         config.setDeleteFromIndividualsAssociation(true);
 321         occurrenceService.delete(associatedFieldUnit, config);
 322         assertTrue(((IndividualsAssociation) descriptionElement).getAssociatedSpecimenOrObservation() == null);
 323
 324     }
 325
 326     @Test
 327     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceService.loadData.xml")
 328     public void testLoadData() {
 329         String fieldUnitUuid = "5a31df5a-2e4d-40b1-8d4e-5754736ae7ef";
 330         String derivedUnitUuid = "18f70977-5d9c-400a-96c4-0cb7a2cd287e";
 331
 332         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(UUID.fromString(fieldUnitUuid));
 333         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(UUID.fromString(derivedUnitUuid));
 334
 335         assertFalse(fieldUnit.getDerivationEvents().iterator().next().getDerivatives().isEmpty());
 336         assertTrue(derivedUnit.getDerivedFrom() != null);
 337     }
 338
 339     @Test
 340     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testListAssociatedAndTypedTaxa.xml")
 341     public void testListIndividualsAssociatensAndSpecimenTypeDesignations(){
 342         UUID fieldUnitUuid = UUID.fromString("b359ff20-98de-46bf-aa43-3e10bb072cd4");
 343         UUID typeSpecimenUuid = UUID.fromString("0f8608c7-ffe7-40e6-828c-cb3382580878");
 344         UUID taxonDescriptionUuid = UUID.fromString("d77db2d4-45a1-4aa1-ab34-f33395f54965");
 345         UUID taxonUuid = UUID.fromString("b0de794c-8cb7-4369-8f83-870ca37abbe0");
 346         // //how the XML was generated
 347         // FieldUnit associatedFieldUnit = FieldUnit.NewInstance();
 348         // associatedFieldUnit.setUuid(fieldUnitUuid);
 349         // //sub derivates (DerivedUnit, DnaSample)
 350         // DerivedUnit typeSpecimen =
 351         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 352         // typeSpecimen.setUuid(typeSpecimenUuid);
 353         //
 354         // //derivation events
 355         // DerivationEvent.NewSimpleInstance(associatedFieldUnit, typeSpecimen,
 356         // DerivationEventType.ACCESSIONING());
 357         //
 358         // occurrenceService.save(associatedFieldUnit);
 359         // occurrenceService.save(typeSpecimen);
 360         //
 361         // //create name with type specimen
 362         // BotanicalName name =
 363         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 364         // SpecimenTypeDesignation typeDesignation =
 365         // SpecimenTypeDesignation.NewInstance();
 366         // typeDesignation.setTypeSpecimen(typeSpecimen);
 367         //
 368         // // create taxon with name and two taxon descriptions (one with
 369         // // IndividualsAssociations and a "described" voucher specimen, and an
 370         // // empty one)
 371         // Taxon taxon = Taxon.NewInstance(name, null);
 372         // taxon.setUuid(taxonUuid);
 373         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 374         // taxonDescription.setUuid(taxonDescriptionUuid);
 375         // //add voucher
 376         // taxonDescription.addElement(IndividualsAssociation.NewInstance(associatedFieldUnit));
 377         // taxon.addDescription(taxonDescription);
 378         // //add type designation to name
 379         // name.addTypeDesignation(typeDesignation, false);
 380         // //add another taxon description to taxon which is not associated with
 381         // a specimen thus should not be taken into account
 382         // taxon.addDescription(TaxonDescription.NewInstance());
 383         // taxonService.saveOrUpdate(taxon);
 384         //
 385         // commitAndStartNewTransaction(null);
 386         //
 387         // setComplete();
 388         // endTransaction();
 389         //
 390         // try {
 391         // writeDbUnitDataSetFile(new String[]{
 392         // "SpecimenOrObservationBase",
 393         // "SpecimenOrObservationBase_DerivationEvent",
 394         // "DerivationEvent",
 395         // "Sequence",
 396         // "Sequence_SingleRead",
 397         // "SingleRead",
 398         // "AmplificationResult",
 399         // "DescriptionElementBase",
 400         // "DescriptionBase",
 401         // "TaxonBase",
 402         // "TypeDesignationBase",
 403         // "TaxonName",
 404         // "TaxonName_TypeDesignationBase",
 405         // "HomotypicalGroup"}, "testListAssociatedAndTypedTaxa");
 406         // } catch (FileNotFoundException e) {
 407         // e.printStackTrace();
 408         // }
 409         //
 410         // System.out.println("associatedFieldUnit.getUuid() " +
 411         // associatedFieldUnit.getUuid());
 412         // System.out.println("typeSpecimen.getUuid() "+typeSpecimen.getUuid());
 413         // System.out.println("taxonDescription.getUuid() "+taxonDescription.getUuid());
 414         // System.out.println("taxon.getUuid() "+taxon.getUuid());
 415
 416         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 417         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(typeSpecimenUuid);
 418         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
 419         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDescriptionUuid);
 420         // check for FieldUnit (IndividualsAssociation)
 421         java.util.Collection<IndividualsAssociation> individualsAssociations = occurrenceService
 422                 .listIndividualsAssociations(associatedFieldUnit, null, null, null, null);
 423         assertEquals("Number of individuals associations is incorrect", 1, individualsAssociations.size());
 424         IndividualsAssociation individualsAssociation = individualsAssociations.iterator().next();
 425         assertTrue("association has wrong type",
 426                 individualsAssociation.getInDescription().isInstanceOf(TaxonDescription.class));
 427         TaxonDescription retrievedTaxonDescription = HibernateProxyHelper.deproxy(
 428                 individualsAssociation.getInDescription(), TaxonDescription.class);
 429         assertEquals(taxonDescription, retrievedTaxonDescription);
 430         assertEquals("Associated taxon is incorrect", taxon, retrievedTaxonDescription.getTaxon());
 431
 432         // check for DerivedUnit (Type Designation should exist)
 433         java.util.Collection<SpecimenTypeDesignation> typeDesignations = occurrenceService.listTypeDesignations(
 434                 typeSpecimen, null, null, null, null);
 435         assertEquals("Number of type designations is incorrect", 1, typeDesignations.size());
 436         SpecimenTypeDesignation specimenTypeDesignation = typeDesignations.iterator().next();
 437         Set<TaxonName> typifiedNames = specimenTypeDesignation.getTypifiedNames();
 438         assertEquals("number of typified names is incorrect", 1, typifiedNames.size());
 439         Set<?> taxonBases = typifiedNames.iterator().next().getTaxonBases();
 440         assertEquals("number of taxa incorrect", 1, taxonBases.size());
 441         Object next = taxonBases.iterator().next();
 442         assertTrue(next instanceof CdmBase && ((CdmBase) next).isInstanceOf(Taxon.class));
 443         assertEquals("Typed taxon is incorrect", taxon, next);
 444     }
 445
 446     @Test
 447     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithSpecimenDescription.xml")
 448     public void testIsDeletableWithSpecimenDescription() {
 449         UUID derivedUnitUuid = UUID.fromString("68095c8e-025d-49f0-8bb2-ed36378b75c3");
 450         UUID specimenDescriptionUuid = UUID.fromString("4094f947-ce84-47b1-bad5-e57e33239d3c");
 451         // //how the XML was generated
 452         // DerivedUnit derivedUnit =
 453         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 454         // derivedUnit.setUuid(derivedUnitUuid);
 455         // SpecimenDescription specimenDescription =
 456         // SpecimenDescription.NewInstance();
 457         // specimenDescription.setUuid(specimenDescriptionUuid);
 458         // derivedUnit.addDescription(specimenDescription);
 459         // occurrenceService.save(derivedUnit);
 460         //
 461         // commitAndStartNewTransaction(null);
 462         //
 463         // setComplete();
 464         // endTransaction();
 465         //
 466         // try {
 467         // writeDbUnitDataSetFile(new String[] {
 468         // "SpecimenOrObservationBase",
 469         // "SpecimenOrObservationBase_DerivationEvent",
 470         // "DerivationEvent",
 471         // "Sequence",
 472         // "Sequence_SingleRead",
 473         // "SingleRead",
 474         // "AmplificationResult",
 475         // "DescriptionElementBase",
 476         // "DescriptionBase",
 477         // "TaxonBase",
 478         // "TypeDesignationBase",
 479         // "TaxonName",
 480         // "TaxonName_TypeDesignationBase",
 481         // "HomotypicalGroup"
 482         // }, "testIsDeletableWithSpecimenDescription");
 483         // } catch (FileNotFoundException e) {
 484         // e.printStackTrace();
 485         // }
 486
 487         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 488         SpecimenDescription specimenDescription = (SpecimenDescription) descriptionService
 489                 .load(specimenDescriptionUuid);
 490
 491         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 492         DeleteResult deleteResult = null;
 493         // delete derivedUnit1
 494         deleteResult = occurrenceService.isDeletable(derivedUnit.getUuid(), config);
 495         //deletion of specimen description should always work because there are no
 496         //specimen description without a specimen
 497         assertTrue(deleteResult.toString(), deleteResult.isOk());
 498         occurrenceService.delete(derivedUnit, config);
 499         specimenDescription = (SpecimenDescription) descriptionService.find(specimenDescriptionUuid);
 500
 501         assertNull(specimenDescription);
 502     }
 503
 504     @Test
 505     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithDescribedSpecimenInTaxonDescription.xml")
 506     public void testIsDeletableWithDescribedSpecimenInTaxonDescription() {
 507         UUID fieldUnitUuid = UUID.fromString("d656a004-38ee-404c-810a-87ffb0ab16c2");
 508         // //how the XML was generated
 509         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 510         // fieldUnit.setUuid(fieldUnitUuid);
 511         // DerivedUnit derivedUnit =
 512         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 513         //
 514         // //derivation events
 515         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 516         // DerivationEventType.ACCESSIONING());
 517         //
 518         // occurrenceService.save(fieldUnit);
 519         // occurrenceService.save(derivedUnit);
 520         //
 521         // // create taxon with name and two taxon descriptions
 522         // //(one with a "described" voucher specimen, and an empty one)
 523         // Taxon taxon =
 524         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual sec L."),
 525         // null);
 526         // taxonDescription.setUuid(taxonDescriptionUuid);
 527         // //add voucher
 528         // taxonDescription.setDescribedSpecimenOrObservation(derivedUnit);
 529         // taxon.addDescription(taxonDescription);
 530         // //add another taxon description to taxon which is not associated with
 531         // a specimen thus should not be taken into account
 532         // taxon.addDescription(TaxonDescription.NewInstance());
 533         // taxonService.saveOrUpdate(taxon);
 534         //
 535         //
 536         // commitAndStartNewTransaction(null);
 537         //
 538         // setComplete();
 539         // endTransaction();
 540         //
 541         //
 542         // try {
 543         // writeDbUnitDataSetFile(new String[] {
 544         // "SpecimenOrObservationBase",
 545         // "SpecimenOrObservationBase_DerivationEvent",
 546         // "DerivationEvent",
 547         // "Sequence",
 548         // "Sequence_SingleRead",
 549         // "SingleRead",
 550         // "AmplificationResult",
 551         // "DescriptionElementBase",
 552         // "DescriptionBase",
 553         // "TaxonBase",
 554         // "TypeDesignationBase",
 555         // "TaxonName",
 556         // "TaxonName_TypeDesignationBase",
 557         // "HomotypicalGroup"
 558         // }, "testIsDeletableWithDescribedSpecimenInTaxonDescription");
 559         // } catch (FileNotFoundException e) {
 560         // e.printStackTrace();
 561         // }
 562
 563         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 564
 565         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 566         DeleteResult deleteResult = null;
 567         // check deletion of field unit -> should fail because of voucher
 568         // specimen (describedSpecimen) in TaxonDescription
 569         deleteResult = occurrenceService.isDeletable(associatedFieldUnit.getUuid(), config);
 570         assertFalse(deleteResult.toString(), deleteResult.isOk());
 571
 572         // allow deletion from TaxonDescription and deletion of child derivates
 573         config.setDeleteFromDescription(true);
 574         config.setDeleteChildren(true);
 575         deleteResult = occurrenceService.isDeletable(associatedFieldUnit.getUuid(), config);
 576         assertTrue(deleteResult.toString(), deleteResult.isOk());
 577     }
 578
 579     @Test
 580     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithIndividualsAssociationTaxonDescription.xml")
 581     public void testIsDeletableWithIndividualsAssociationTaxonDescription() {
 582         UUID fieldUnitUuid = UUID.fromString("7978b978-5100-4c7a-82ef-3a23e0f3c723");
 583         UUID taxonDescriptionUuid = UUID.fromString("d4b0d561-6e7e-4fd8-bf3c-925530f949eb");
 584         // //how the XML was generated
 585         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 586         // fieldUnit.setUuid(fieldUnitUuid);
 587         //
 588         // occurrenceService.save(fieldUnit);
 589         //
 590         // // create taxon with name and two taxon descriptions (one with
 591         // // IndividualsAssociations and a "described" voucher specimen, and an
 592         // // empty one)
 593         // Taxon taxon =
 594         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual sec L."),
 595         // null);
 596         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 597         // taxonDescription.setUuid(taxonDescriptionUuid);
 598         // //add voucher
 599         // taxonDescription.addElement(IndividualsAssociation.NewInstance(fieldUnit));
 600         // taxon.addDescription(taxonDescription);
 601         // //add another taxon description to taxon which is not associated with
 602         // a specimen thus should not be taken into account
 603         // taxon.addDescription(TaxonDescription.NewInstance());
 604         // taxonService.saveOrUpdate(taxon);
 605         //
 606         //
 607         // commitAndStartNewTransaction(null);
 608         //
 609         // setComplete();
 610         // endTransaction();
 611         //
 612         //
 613         // try {
 614         // writeDbUnitDataSetFile(new String[] {
 615         // "SpecimenOrObservationBase",
 616         // "SpecimenOrObservationBase_DerivationEvent",
 617         // "DerivationEvent",
 618         // "Sequence",
 619         // "Sequence_SingleRead",
 620         // "SingleRead",
 621         // "AmplificationResult",
 622         // "DescriptionElementBase",
 623         // "DescriptionBase",
 624         // "TaxonBase",
 625         // "TypeDesignationBase",
 626         // "TaxonName",
 627         // "TaxonName_TypeDesignationBase",
 628         // "HomotypicalGroup"
 629         // }, "testIsDeletableWithIndividualsAssociationTaxonDescription");
 630         // } catch (FileNotFoundException e) {
 631         // e.printStackTrace();
 632         // }
 633
 634         FieldUnit associatedFieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 635         TaxonDescription taxonDescription = (TaxonDescription) descriptionService.load(taxonDescriptionUuid);
 636         IndividualsAssociation individualsAssociation = (IndividualsAssociation) taxonDescription.getElements()
 637                 .iterator().next();
 638
 639         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 640         DeleteResult deleteResult = null;
 641         // check deletion of field unit -> should fail because of
 642         // IndividualAssociation
 643         deleteResult = occurrenceService.isDeletable(associatedFieldUnit.getUuid(), config);
 644         assertFalse(deleteResult.toString(), deleteResult.isOk());
 645         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(individualsAssociation));
 646
 647         // allow deletion of individuals association
 648         config.setDeleteFromIndividualsAssociation(true);
 649         deleteResult = occurrenceService.isDeletable(associatedFieldUnit.getUuid(), config);
 650         assertTrue(deleteResult.toString(), deleteResult.isOk());
 651
 652     }
 653
 654     @Test
 655     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithTypeDesignation.xml")
 656     public void testIsDeletableWithTypeDesignation() {
 657         UUID derivedUnitUuid = UUID.fromString("f7fd1dc1-3c93-42a7-8279-cde5bfe37ea0");
 658         UUID botanicalNameUuid = UUID.fromString("7396430c-c932-4dd3-a45a-40c2808b132e");
 659         // DerivedUnit derivedUnit =
 660         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 661         // derivedUnit.setUuid(derivedUnitUuid);
 662         //
 663         // occurrenceService.save(derivedUnit);
 664         //
 665         // //create name with type specimen
 666         // BotanicalName name =
 667         // BotanicalName.PARSED_NAME("Campanula patual sec L.");
 668         // name.setUuid(botanicalNameUuid);
 669         // SpecimenTypeDesignation typeDesignation =
 670         // SpecimenTypeDesignation.NewInstance();
 671         // typeDesignation.setTypeSpecimen(derivedUnit);
 672         // //add type designation to name
 673         // name.addTypeDesignation(typeDesignation, false);
 674         //
 675         // nameService.saveOrUpdate(name);
 676         //
 677         // commitAndStartNewTransaction(null);
 678         //
 679         // setComplete();
 680         // endTransaction();
 681         //
 682         //
 683         // try {
 684         // writeDbUnitDataSetFile(new String[] {
 685         // "SpecimenOrObservationBase",
 686         // "SpecimenOrObservationBase_DerivationEvent",
 687         // "DerivationEvent",
 688         // "Sequence",
 689         // "Sequence_SingleRead",
 690         // "SingleRead",
 691         // "AmplificationResult",
 692         // "DescriptionElementBase",
 693         // "DescriptionBase",
 694         // "TaxonBase",
 695         // "TypeDesignationBase",
 696         // "TaxonName",
 697         // "TaxonName_TypeDesignationBase",
 698         // "HomotypicalGroup"
 699         // }, "testIsDeletableWithTypeDesignation");
 700         // } catch (FileNotFoundException e) {
 701         // e.printStackTrace();
 702         // }
 703
 704         DerivedUnit typeSpecimen = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 705
 706         // create name with type specimen
 707         IBotanicalName name = nameService.load(botanicalNameUuid);
 708         SpecimenTypeDesignation typeDesignation = (SpecimenTypeDesignation) name.getTypeDesignations().iterator()
 709                 .next();
 710
 711         // add type designation to name
 712         name.addTypeDesignation(typeDesignation, false);
 713
 714         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 715         DeleteResult deleteResult = null;
 716
 717         // check deletion of specimen
 718         deleteResult = occurrenceService.isDeletable(typeSpecimen.getUuid(), config);
 719         assertFalse(deleteResult.toString(), deleteResult.isOk());
 720         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(typeDesignation));
 721
 722         // allow deletion of type designation
 723         config.setDeleteFromTypeDesignation(true);
 724
 725         deleteResult = occurrenceService.isDeletable(typeSpecimen.getUuid(), config);
 726         assertTrue(deleteResult.toString(), deleteResult.isOk());
 727     }
 728
 729     @Test
 730     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testIsDeletableWithChildren.xml")
 731     public void testIsDeletableWithChildren() {
 732         UUID fieldUnitUuid = UUID.fromString("92ada058-4c14-4131-8ecd-b82dc1dd2882");
 733         UUID derivedUnitUuid = UUID.fromString("896dffdc-6809-4914-8950-5501fee1c0fd");
 734         UUID dnaSampleUuid = UUID.fromString("7efd1d66-ac7f-4202-acdf-a72cbb9c3a21");
 735         // if this test fails be sure to check if there are left-over elements
 736         // in the DB
 737         // e.g. clear by adding "<AMPLIFICATIONRESULT/>" to the data set XML
 738
 739         // //how the XML was generated
 740         // FieldUnit fieldUnit = FieldUnit.NewInstance();
 741         // fieldUnit.setUuid(fieldUnitUuid);
 742         // //sub derivates (DerivedUnit, DnaSample)
 743         // DerivedUnit derivedUnit =
 744         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 745         // derivedUnit.setUuid(derivedUnitUuid);
 746         // DnaSample dnaSample = DnaSample.NewInstance();
 747         // dnaSample.setUuid(dnaSampleUuid);
 748         //
 749         // //derivation events
 750         // DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit,
 751         // DerivationEventType.ACCESSIONING());
 752         // DerivationEvent.NewSimpleInstance(derivedUnit, dnaSample,
 753         // DerivationEventType.DNA_EXTRACTION());
 754         //
 755         // occurrenceService.save(fieldUnit);
 756         // occurrenceService.save(derivedUnit);
 757         // occurrenceService.save(dnaSample);
 758         //
 759         // commitAndStartNewTransaction(null);
 760         //
 761         // setComplete();
 762         // endTransaction();
 763         //
 764         // try {
 765         // writeDbUnitDataSetFile(new String[] {
 766         // "SpecimenOrObservationBase",
 767         // "SpecimenOrObservationBase_DerivationEvent",
 768         // "DerivationEvent",
 769         // "Sequence",
 770         // "SingleRead",
 771         // "SingleReadAlignment",
 772         // "Amplification",
 773         // "AmplificationResult",
 774         // "DescriptionElementBase",
 775         // "DescriptionBase",
 776         // "TaxonBase",
 777         // "TypeDesignationBase",
 778         // "TaxonName",
 779         // "TaxonName_TypeDesignationBase",
 780         // "HomotypicalGroup"
 781         // }, "testIsDeletableWithChildren");
 782         // } catch (FileNotFoundException e) {
 783         // e.printStackTrace();
 784         // }
 785         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 786         // sub derivates (DerivedUnit, DnaSample)
 787         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 788         DnaSample dnaSample = (DnaSample) occurrenceService.load(dnaSampleUuid);
 789
 790         // derivation events
 791         DerivationEvent fieldUnitToDerivedUnitEvent = fieldUnit.getDerivationEvents().iterator().next();
 792         DerivationEvent derivedUnitToDnaSampleEvent = derivedUnit.getDerivationEvents().iterator().next();
 793
 794         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 795
 796         DeleteResult deleteResult = null;
 797         // check deletion of DnaSample
 798         deleteResult = occurrenceService.isDeletable(dnaSample.getUuid(), config);
 799         assertTrue(deleteResult.toString(), deleteResult.isOk());
 800
 801         // check deletion of Specimen
 802         deleteResult = occurrenceService.isDeletable(derivedUnit.getUuid(), config);
 803         assertFalse(deleteResult.toString(), deleteResult.isOk());
 804         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(derivedUnitToDnaSampleEvent));
 805
 806         // check deletion of fieldUnit
 807         deleteResult = occurrenceService.isDeletable(fieldUnit.getUuid(), config);
 808         assertFalse(deleteResult.toString(), deleteResult.isOk());
 809         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(fieldUnitToDerivedUnitEvent));
 810
 811         // check deletion of Specimen
 812         config.setDeleteChildren(true);
 813         deleteResult = occurrenceService.isDeletable(derivedUnit.getUuid(), config);
 814         assertTrue(deleteResult.toString(), deleteResult.isOk());
 815         assertTrue(deleteResult.toString(), deleteResult.getRelatedObjects().contains(derivedUnitToDnaSampleEvent));
 816
 817         // check deletion of fieldUnit
 818         config.setDeleteFromDescription(true);
 819         deleteResult = occurrenceService.isDeletable(fieldUnit.getUuid(), config);
 820         assertTrue(deleteResult.toString(), deleteResult.isOk());
 821
 822     }
 823
 824     @Test
 825     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceTest.testListAssociatedTaxaAndListByAssociatedTaxon.xml")
 826     public void testListAssociatedTaxaAndListByAssociatedTaxon(){
 827         UUID associatedSpecimenUuid = UUID.fromString("6478a387-bc77-4f1b-bfab-671ad786a27e");
 828         UUID unassociatedSpecimenUuid = UUID.fromString("820e1af6-9bff-4244-97d3-81fd9a49c91c");
 829         UUID typeSpecimenUuid = UUID.fromString("b6f31b9f-f9e2-4bc7-883e-35bd6a9978b4");
 830         UUID taxonUuid = UUID.fromString("5613698d-840b-4034-b9b1-1302938e183b");
 831 //      DerivedUnit typeSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
 832 //      DerivedUnit associatedSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 833 //      DerivedUnit unassociatedSpecimen = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
 834 //      typeSpecimen.setUuid(typeSpecimenUuid);
 835 //      associatedSpecimen.setUuid(associatedSpecimenUuid);
 836 //      unassociatedSpecimen.setUuid(unassociatedSpecimenUuid);
 837 //
 838 //      occurrenceService.save(typeSpecimen);
 839 //      occurrenceService.save(associatedSpecimen);
 840 //      occurrenceService.save(unassociatedSpecimen);
 841 //
 842 //      BotanicalName name = BotanicalName.PARSED_NAME("Campanula patula");
 843 //      SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();
 844 //      typeDesignation.setTypeSpecimen(typeSpecimen);
 845 //      name.addTypeDesignation(typeDesignation, false);
 846 //
 847 //      Taxon taxon = Taxon.NewInstance(name, null);
 848 //      taxon.setUuid(taxonUuid);
 849 //      TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 850 ////      taxonDescription.setUuid(taxonDescriptionUuid);
 851 //
 852 //      taxonDescription.addElement(IndividualsAssociation.NewInstance(associatedSpecimen));
 853 //      taxon.addDescription(taxonDescription);
 854 //
 855 //      taxonService.saveOrUpdate(taxon);
 856 //
 857 //      commitAndStartNewTransaction(null);
 858 //
 859 //      setComplete();
 860 //      endTransaction();
 861 //
 862 //      try {
 863 //          writeDbUnitDataSetFile(new String[]{
 864 //                                 "SpecimenOrObservationBase",
 865 //                  "SpecimenOrObservationBase_DerivationEvent",
 866 //                  "DerivationEvent",
 867 //                  "Sequence",
 868 //                  "Sequence_SingleRead",
 869 //                  "SingleRead",
 870 //                  "AmplificationResult",
 871 //                  "DescriptionElementBase",
 872 //                  "DescriptionBase",
 873 //                  "TaxonBase",
 874 //                  "TypeDesignationBase",
 875 //                  "TaxonName",
 876 //                  "TaxonName_TypeDesignationBase",
 877 //                  "TeamOrPersonBase",
 878 //                  "HomotypicalGroup"}, "testListAssociatedTaxaAndListByAssociatedTaxon");
 879 //      } catch (FileNotFoundException e) {
 880 //          e.printStackTrace();
 881 //      }
 882         //check initial state
 883         SpecimenOrObservationBase typeSpecimen = occurrenceService.load(typeSpecimenUuid);
 884         SpecimenOrObservationBase associatedSpecimen = occurrenceService.load(associatedSpecimenUuid);
 885         SpecimenOrObservationBase unassociatedSpecimen = occurrenceService.load(unassociatedSpecimenUuid);
 886         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
 887
 888         assertNotNull(typeSpecimen);
 889         assertNotNull(associatedSpecimen);
 890         assertNotNull(unassociatedSpecimen);
 891         assertNotNull(taxon);
 892
 893         //check association (IndividualsAssociations + TypeDesignations) specimen -> taxon (name)
 894
 895         //unassociated specimen
 896         java.util.Collection<TaxonBase<?>> associatedTaxa = occurrenceService.listAssociatedTaxa(unassociatedSpecimen, null, null, null, null);
 897         assertNotNull(associatedTaxa);
 898         assertTrue(associatedTaxa.isEmpty());
 899
 900         //type specimen
 901         associatedTaxa = occurrenceService.listAssociatedTaxa(typeSpecimen, null, null, null, null);
 902         assertNotNull(associatedTaxa);
 903         assertEquals(1, associatedTaxa.size());
 904         assertEquals(taxon, associatedTaxa.iterator().next());
 905
 906         //associated specimen
 907         associatedTaxa = occurrenceService.listAssociatedTaxa(associatedSpecimen, null, null, null, null);
 908         assertNotNull(associatedTaxa);
 909         assertEquals(1, associatedTaxa.size());
 910         assertEquals(taxon, associatedTaxa.iterator().next());
 911
 912
 913         //check association (IndividualsAssociations + TypeDesignations) taxon (name) -> specimen
 914         List<DerivedUnit> byAssociatedTaxon = occurrenceService.listByAssociatedTaxon(DerivedUnit.class, null, taxon, null, null, null, null, null);
 915         assertNotNull(byAssociatedTaxon);
 916         assertEquals(2, byAssociatedTaxon.size());
 917         assertTrue(byAssociatedTaxon.contains(associatedSpecimen));
 918         assertTrue(byAssociatedTaxon.contains(typeSpecimen));
 919         assertTrue(!byAssociatedTaxon.contains(unassociatedSpecimen));
 920
 921     }
 922
 923     @Test
 924     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testFindOcurrences.xml")
 925     public void testFindOccurrences() {
 926         UUID derivedUnit1Uuid = UUID.fromString("843bc8c9-c0fe-4735-bf40-82f1996dcefb");
 927         UUID derivedUnit2Uuid = UUID.fromString("40cd9cb1-7c74-4e7d-a1f8-8a1e0314e940");
 928         UUID dnaSampleUuid = UUID.fromString("364969a6-2457-4e2e-ae1e-29a6fcaa741a");
 929         UUID dnaSampleWithSequenceUuid = UUID.fromString("571d4e9a-0736-4da3-ad4a-a2df427a1f01");
 930         UUID tissueUuid = UUID.fromString("b608613c-1b5a-4882-8b14-d643b6fc5998");
 931
 932         UUID taxonUuid = UUID.fromString("dfca7629-8a60-4d51-998d-371897f725e9");
 933
 934         // DerivedUnit derivedUnit =
 935         // DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 936         // derivedUnit.setTitleCache("testUnit1");
 937         // derivedUnit.setAccessionNumber("ACC1");
 938         // DerivedUnit derivedUnit2 =
 939         // DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
 940         // derivedUnit2.setTitleCache("testUnit2");
 941         // derivedUnit2.setBarcode("ACC2");
 942         // DerivedUnit dnaSample =
 943         // DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
 944         // dnaSample.setTitleCache("dna");
 945         // dnaSample.setCatalogNumber("ACC1");
 946         // DerivedUnit tissue =
 947         // DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
 948         // tissue.setTitleCache("tissue");
 949         //
 950         // DerivationEvent.NewSimpleInstance(derivedUnit, dnaSample,
 951         // DerivationEventType.DNA_EXTRACTION());
 952         //
 953         // derivedUnit.setUuid(derivedUnit1Uuid);
 954         // derivedUnit2.setUuid(derivedUnit2Uuid);
 955         // dnaSample.setUuid(dnaSampleUuid);
 956         // tissue.setUuid(tissueUuid);
 957         //
 958         // occurrenceService.save(derivedUnit);
 959         // occurrenceService.save(derivedUnit2);
 960         // occurrenceService.save(dnaSample);
 961         // occurrenceService.save(tissue);
 962         //
 963         // Taxon taxon =
 964         // Taxon.NewInstance(BotanicalName.PARSED_NAME("Campanula patual"),
 965         // null);
 966         // taxon.setUuid(taxonUuid);
 967         // TaxonDescription taxonDescription = TaxonDescription.NewInstance();
 968         // taxonDescription.setUuid(UUID.fromString("272d4d28-662c-468e-94d8-16993fab91ba"));
 969         // //add voucher
 970         // taxonDescription.addElement(IndividualsAssociation.NewInstance(derivedUnit));
 971         // taxonDescription.addElement(IndividualsAssociation.NewInstance(tissue));
 972         // taxon.addDescription(taxonDescription);
 973         // taxonService.saveOrUpdate(taxon);
 974         //
 975         // commitAndStartNewTransaction(null);
 976         //
 977         // setComplete();
 978         // endTransaction();
 979         //
 980         //
 981         // try {
 982         // writeDbUnitDataSetFile(new String[] {
 983         // "SpecimenOrObservationBase",
 984         // "SpecimenOrObservationBase_DerivationEvent",
 985         // "DerivationEvent",
 986         // "DescriptionElementBase",
 987         // "DescriptionBase",
 988         // "TaxonBase",
 989         // "TypeDesignationBase",
 990         // "TaxonName",
 991         // "TaxonName_TypeDesignationBase",
 992         // "HomotypicalGroup",
 993         // "TeamOrPersonBase"
 994         // }, "testFindOcurrences");
 995         // } catch (FileNotFoundException e) {
 996         // e.printStackTrace();
 997         // }
 998
 999         SpecimenOrObservationBase derivedUnit1 = occurrenceService.load(derivedUnit1Uuid);
1000         SpecimenOrObservationBase derivedUnit2 = occurrenceService.load(derivedUnit2Uuid);
1001         SpecimenOrObservationBase tissue = occurrenceService.load(tissueUuid);
1002         SpecimenOrObservationBase dnaSample = occurrenceService.load(dnaSampleUuid);
1003         SpecimenOrObservationBase dnaSampleWithSequence = occurrenceService.load(dnaSampleWithSequenceUuid);
1004         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
1005
1006         assertNotNull(derivedUnit1);
1007         assertNotNull(derivedUnit2);
1008         assertNotNull(tissue);
1009         assertNotNull(dnaSample);
1010         assertNotNull(taxon);
1011
1012         // wildcard search => all derivates
1013         FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();
1014         config.setTitleSearchString("*");
1015         assertEquals(5, occurrenceService.countOccurrences(config));
1016         List<SpecimenOrObservationBase> allDerivates = occurrenceService.findByTitle(config).getRecords();
1017         assertEquals(5, allDerivates.size());
1018         assertTrue(allDerivates.contains(derivedUnit1));
1019         assertTrue(allDerivates.contains(derivedUnit2));
1020         assertTrue(allDerivates.contains(tissue));
1021         assertTrue(allDerivates.contains(dnaSample));
1022
1023         // queryString search => 2 derivates
1024         config = new FindOccurrencesConfigurator();
1025         config.setTitleSearchString("test*");
1026         // config.setClazz(SpecimenOrObservationBase.class);
1027         assertEquals(2, occurrenceService.countOccurrences(config));
1028         List<SpecimenOrObservationBase> queryStringDerivates = occurrenceService.findByTitle(config).getRecords();
1029         assertEquals(2, queryStringDerivates.size());
1030         assertTrue(queryStringDerivates.contains(derivedUnit1));
1031         assertTrue(queryStringDerivates.contains(derivedUnit2));
1032
1033         // class search => 4 results
1034         config = new FindOccurrencesConfigurator();
1035         config.setClazz(SpecimenOrObservationBase.class);
1036         assertEquals(5, occurrenceService.countOccurrences(config));
1037         List<SpecimenOrObservationBase> specimenOrObservationBases = occurrenceService.findByTitle(config).getRecords();
1038         assertEquals(5, specimenOrObservationBases.size());
1039
1040         // class search => 0 results
1041         config = new FindOccurrencesConfigurator();
1042         config.setClazz(FieldUnit.class);
1043         assertEquals(0, occurrenceService.countOccurrences(config));
1044         List<SpecimenOrObservationBase> fieldUnits = occurrenceService.findByTitle(config).getRecords();
1045         assertEquals(0, fieldUnits.size());
1046
1047         // class search => 4 results
1048         config = new FindOccurrencesConfigurator();
1049         config.setClazz(DerivedUnit.class);
1050         assertEquals(5, occurrenceService.countOccurrences(config));
1051         List<SpecimenOrObservationBase> derivedUnits = occurrenceService.findByTitle(config).getRecords();
1052         assertEquals(5, derivedUnits.size());
1053         assertTrue(derivedUnits.contains(derivedUnit1));
1054         assertTrue(derivedUnits.contains(derivedUnit2));
1055         assertTrue(derivedUnits.contains(tissue));
1056         assertTrue(derivedUnits.contains(dnaSample));
1057
1058         // significant identifier search
1059         config = new FindOccurrencesConfigurator();
1060         config.setClazz(DerivedUnit.class);
1061         config.setSignificantIdentifier("ACC1");
1062         assertEquals(2, occurrenceService.countOccurrences(config));
1063         List<SpecimenOrObservationBase> accessionedUnits = occurrenceService.findByTitle(config).getRecords();
1064         assertEquals(2, accessionedUnits.size());
1065         assertTrue(accessionedUnits.contains(derivedUnit1));
1066         assertFalse(accessionedUnits.contains(derivedUnit2));
1067         assertFalse(accessionedUnits.contains(tissue));
1068         assertTrue(accessionedUnits.contains(dnaSample));
1069
1070         config = new FindOccurrencesConfigurator();
1071         config.setClazz(DerivedUnit.class);
1072         config.setSignificantIdentifier("ACC2");
1073         assertEquals(1, occurrenceService.countOccurrences(config));
1074         List<SpecimenOrObservationBase> barcodedUnits = occurrenceService.findByTitle(config).getRecords();
1075         assertEquals(1, barcodedUnits.size());
1076         assertFalse(barcodedUnits.contains(derivedUnit1));
1077         assertTrue(barcodedUnits.contains(derivedUnit2));
1078         assertFalse(barcodedUnits.contains(tissue));
1079         assertFalse(barcodedUnits.contains(dnaSample));
1080
1081         // recordBasis search => 1 Fossil
1082         config = new FindOccurrencesConfigurator();
1083         config.setSpecimenType(SpecimenOrObservationType.Fossil);
1084         assertEquals(1, occurrenceService.countOccurrences(config));
1085         List<SpecimenOrObservationBase> fossils = occurrenceService.findByTitle(config).getRecords();
1086         assertEquals(1, fossils.size());
1087         assertTrue(fossils.contains(derivedUnit1));
1088
1089         // taxon determination search => 2 associated specimens
1090         config = new FindOccurrencesConfigurator();
1091         config.setClazz(DerivedUnit.class);
1092         config.setAssociatedTaxonUuid(taxon.getUuid());
1093         assertEquals(2, occurrenceService.countOccurrences(config));
1094         List<SpecimenOrObservationBase> associatedSpecimens = occurrenceService.findByTitle(config).getRecords();
1095         assertEquals(2, associatedSpecimens.size());
1096         assertTrue(associatedSpecimens.contains(derivedUnit1));
1097         assertTrue(associatedSpecimens.contains(tissue));
1098
1099         // taxon determination search (indirectly associated) => 3 associated
1100         // specimens
1101         config = new FindOccurrencesConfigurator();
1102         config.setClazz(DerivedUnit.class);
1103         config.setAssociatedTaxonUuid(taxon.getUuid());
1104         config.setRetrieveIndirectlyAssociatedSpecimens(true);
1105         assertEquals(3, occurrenceService.countOccurrences(config));
1106         List<SpecimenOrObservationBase> indirectlyAssociatedSpecimens = occurrenceService.findByTitle(config)
1107                 .getRecords();
1108         assertEquals(3, indirectlyAssociatedSpecimens.size());
1109         assertTrue(indirectlyAssociatedSpecimens.contains(derivedUnit1));
1110         assertTrue(indirectlyAssociatedSpecimens.contains(dnaSample));
1111         assertTrue(indirectlyAssociatedSpecimens.contains(tissue));
1112
1113         // taxon association search
1114         config = new FindOccurrencesConfigurator();
1115         config.setClazz(SpecimenOrObservationBase.class);
1116         config.setAssociatedTaxonUuid(taxon.getUuid());
1117         assertEquals(2, occurrenceService.countOccurrences(config));
1118         List<SpecimenOrObservationBase> specimensOrObservations = occurrenceService.findByTitle(config).getRecords();
1119         assertEquals(2, specimensOrObservations.size());
1120         assertTrue(specimensOrObservations.contains(tissue));
1121         assertTrue(specimensOrObservations.contains(derivedUnit1));
1122
1123         //test assignment status
1124         //all specimen
1125         config = new FindOccurrencesConfigurator();
1126         config.setAssignmentStatus(AssignmentStatus.ALL_SPECIMENS);
1127         assertEquals(5, occurrenceService.countOccurrences(config));
1128         List<SpecimenOrObservationBase> allSpecimens = occurrenceService.findByTitle(config).getRecords();
1129         assertEquals(5, allSpecimens.size());
1130         assertTrue(allSpecimens.contains(derivedUnit1));
1131         assertTrue(allSpecimens.contains(derivedUnit2));
1132         assertTrue(allSpecimens.contains(tissue));
1133         assertTrue(allSpecimens.contains(dnaSample));
1134
1135         //assigned specimen
1136         config = new FindOccurrencesConfigurator();
1137         config.setAssignmentStatus(AssignmentStatus.ASSIGNED_SPECIMENS);
1138         assertEquals(2, occurrenceService.countOccurrences(config));
1139         List<SpecimenOrObservationBase> assignedSpecimens = occurrenceService.findByTitle(config).getRecords();
1140         assertEquals(2, assignedSpecimens.size());
1141         assertTrue(assignedSpecimens.contains(derivedUnit1));
1142         assertTrue(assignedSpecimens.contains(tissue));
1143
1144         //unassigned specimen
1145         config = new FindOccurrencesConfigurator();
1146         config.setAssignmentStatus(AssignmentStatus.UNASSIGNED_SPECIMENS);
1147         assertEquals(3, occurrenceService.countOccurrences(config));
1148         List<SpecimenOrObservationBase> unAssignedSpecimens = occurrenceService.findByTitle(config).getRecords();
1149         assertEquals(3, unAssignedSpecimens.size());
1150         assertTrue(unAssignedSpecimens.contains(derivedUnit2));
1151         assertTrue(unAssignedSpecimens.contains(dnaSample));
1152
1153         //ignore assignment status because taxon uuid is set
1154         config = new FindOccurrencesConfigurator();
1155         config.setAssociatedTaxonUuid(taxon.getUuid());
1156         config.setAssignmentStatus(AssignmentStatus.UNASSIGNED_SPECIMENS);
1157         assertEquals(2, occurrenceService.countOccurrences(config));
1158         List<SpecimenOrObservationBase> ignoreAssignmentStatusSpecimens = occurrenceService.findByTitle(config).getRecords();
1159         assertEquals(2, ignoreAssignmentStatusSpecimens.size());
1160         assertTrue(ignoreAssignmentStatusSpecimens.contains(derivedUnit1));
1161         assertTrue(ignoreAssignmentStatusSpecimens.contains(tissue));
1162
1163
1164
1165         List<DerivedUnit> findByAccessionNumber = occurrenceService.findByAccessionNumber("ACC_DNA", 10, 1, null, null);
1166
1167         assertEquals(1, findByAccessionNumber.size());
1168        // assertTrue(findByAccessionNumber.contains(derivedUnit1));
1169         assertTrue(findByAccessionNumber.contains(dnaSampleWithSequence));
1170
1171
1172     }
1173
1174     @Test
1175     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest-testAllKindsOfSpecimenAssociations.xml")
1176     public void testListUuidAndTitleCacheByAssociatedTaxon() {
1177         UUID taxonNodeUuid = UUID.fromString("6b8b6ff9-66e4-4496-8e5a-7d03bdf9a076");
1178         /**
1179          * Structure is as follows:
1180          *
1181          * Taxon ----IndividualsAssociation---> DnaSample
1182          * Taxon ----TypeDesignation---> Fossil
1183          * Taxon ----Determination ---> PreservedSpecimenA
1184          *
1185          * Taxon ---> Taxon Name ----Determination ---> PreservedSpecimenB
1186          *
1187          * Taxon ---> Synonym ---> SynonymName ----Determination---> PreservedSpecimenC
1188          *
1189          * Orphan Name (not associated with any taxon) ----Determination ---> PreservedSpecimenD
1190          */
1191
1192         //UUIDS
1193         UUID derivedUnitDeterminationTaxonUuid = UUID.fromString("941b8b22-1925-4b91-8ff8-97114499bb22");
1194         UUID derivedUnitDeterminationNameUuid = UUID.fromString("0cdc7a57-6f55-45c8-b3e5-523748c381e7");
1195         UUID derivedUnitDeterminationSynonymNameUuid = UUID.fromString("d940a940-8caf-4a52-b1d8-ba4aad7ddae2");
1196         UUID derivedUnitDeterminationOrphanNameUuid = UUID.fromString("587b7297-7d59-4f59-8ef3-c7a559cadeca");
1197         UUID tissueUuidNoAssociationUuid = UUID.fromString("93e94260-5107-4b2c-9ce4-da9e1a4e7cb9");
1198         UUID dnaSampleUuidIndividualsAssociationUuid = UUID.fromString("1fb53903-c9b9-4078-8297-5b86aec7fe21");
1199         UUID fossilTypeDesignationUuid = UUID.fromString("42ec8dcf-a923-4256-bbd5-b0d10f4de5e2");
1200         UUID taxonUuid = UUID.fromString("07cc47a5-1a63-46a1-8366-0d59d2b90d5b");
1201
1202         /*
1203          * search for taxon node
1204          * should retrieve all specimens associated via
1205          *  - type designations (fossil)
1206          *  - individuals associations (dnaSample)
1207          *  - determinations on
1208          *   - taxon (specimenA)
1209          *   - taxon name (specimenA, specimenB)
1210          */
1211         FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();
1212         config.setAssociatedTaxonUuid(taxonUuid);
1213         Collection<SpecimenNodeWrapper> specimens = occurrenceService
1214                 .listUuidAndTitleCacheByAssociatedTaxon(Collections.singletonList(taxonNodeUuid), null, null);
1215         List<UUID> uuidList = specimens.stream().map(specimen ->
1216         specimen.getUuidAndTitleCache().getUuid()).collect(Collectors.toList());
1217         assertTrue(uuidList.contains(derivedUnitDeterminationNameUuid));
1218         assertTrue(uuidList.contains(derivedUnitDeterminationTaxonUuid));
1219         assertFalse(uuidList.contains(derivedUnitDeterminationSynonymNameUuid));
1220         assertTrue(uuidList.contains(dnaSampleUuidIndividualsAssociationUuid));
1221         assertTrue(uuidList.contains(fossilTypeDesignationUuid));
1222         assertFalse(uuidList.contains(tissueUuidNoAssociationUuid));
1223         assertFalse(uuidList.contains(derivedUnitDeterminationOrphanNameUuid));
1224         assertEquals("Wrong number of associated specimens", 4, specimens.size());
1225     }
1226
1227     /**
1228      * This will test the retrieval of specimens that are in any way associated
1229      * with a taxon resp. taxon name via type designation, determination event
1230      * or individuals associations. It will also consider synonym relationships.
1231      */
1232     @Test
1233     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest-testAllKindsOfSpecimenAssociations.xml")
1234     public void testAllKindsOfSpecimenAssociations() {
1235
1236         /**
1237          * Structure is as follows:
1238          *
1239          * Taxon ----IndividualsAssociation---> DnaSample
1240          * Taxon ----TypeDesignation---> Fossil
1241          * Taxon ----Determination ---> PreservedSpecimenA
1242          *
1243          * Taxon ---> Taxon Name ----Determination ---> PreservedSpecimenB
1244          *
1245          * Taxon ---> Synonym ---> SynonymName ----Determination---> PreservedSpecimenC
1246          *
1247          * Orphan Name (not associated with any taxon) ----Determination ---> PreservedSpecimenD
1248          */
1249
1250         //UUIDS
1251         UUID derivedUnitDeterminationTaxonUuid = UUID.fromString("941b8b22-1925-4b91-8ff8-97114499bb22");
1252         UUID derivedUnitDeterminationNameUuid = UUID.fromString("0cdc7a57-6f55-45c8-b3e5-523748c381e7");
1253
1254         UUID derivedUnitDeterminationSynonymUuid = UUID.fromString("8eb94a7d-c802-49a7-bc10-c26de20a52c2");
1255         UUID derivedUnitDeterminationSynonymNameUuid = UUID.fromString("d940a940-8caf-4a52-b1d8-ba4aad7ddae2");
1256
1257         UUID derivedUnitDeterminationOrphanNameUuid = UUID.fromString("587b7297-7d59-4f59-8ef3-c7a559cadeca");
1258
1259         UUID tissueUuidNoAssociationUuid = UUID.fromString("93e94260-5107-4b2c-9ce4-da9e1a4e7cb9");
1260         UUID dnaSampleUuidIndividualsAssociationUuid = UUID.fromString("1fb53903-c9b9-4078-8297-5b86aec7fe21");
1261         UUID fossilTypeDesignationUuid = UUID.fromString("42ec8dcf-a923-4256-bbd5-b0d10f4de5e2");
1262
1263         UUID taxonUuid = UUID.fromString("07cc47a5-1a63-46a1-8366-0d59d2b90d5b");
1264         UUID synoymUuid = UUID.fromString("c16bcd9b-7d18-4fb5-af60-f9ef14c1d3a9");
1265
1266         UUID taxonNameUuid = UUID.fromString("e59b95c0-9ad6-48be-af62-a982ba72b917");
1267         UUID synonymNameUuid = UUID.fromString("39f04b2a-b8bd-46e8-9102-ab665c64ec8e");
1268         UUID orphanNameUuid = UUID.fromString("d8e56365-3ad9-4b0e-88bf-acaaab223a9b");
1269
1270         //load cdm entities
1271         DerivedUnit derivedUnitDeterminationTaxon = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationTaxonUuid);
1272         DerivedUnit derivedUnitDeterminationName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationNameUuid);
1273         DerivedUnit derivedUnitDeterminationSynonym = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationSynonymUuid);
1274         DerivedUnit derivedUnitDeterminationSynonymName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationSynonymNameUuid);
1275         DerivedUnit derivedUnitDeterminationOrphanName = (DerivedUnit) occurrenceService.load(derivedUnitDeterminationOrphanNameUuid);
1276         DerivedUnit tissueUuidNoAssociation = (DerivedUnit) occurrenceService.load(tissueUuidNoAssociationUuid);
1277         DnaSample dnaSampleUuidIndividualsAssociation = (DnaSample) occurrenceService.load(dnaSampleUuidIndividualsAssociationUuid);
1278         DerivedUnit fossilTypeDesignation = (DerivedUnit) occurrenceService.load(fossilTypeDesignationUuid);
1279         Taxon taxon = (Taxon) taxonService.load(taxonUuid);
1280         Synonym synonym = (Synonym) taxonService.load(synoymUuid);
1281         TaxonName taxonName = nameService.load(taxonNameUuid);
1282         TaxonName synonymName = nameService.load(synonymNameUuid);
1283         TaxonName orphanName = nameService.load(orphanNameUuid);
1284
1285         //check initial state
1286         assertNotNull(derivedUnitDeterminationTaxon);
1287         assertNotNull(derivedUnitDeterminationName);
1288         assertNotNull(derivedUnitDeterminationSynonym);
1289         assertNotNull(derivedUnitDeterminationSynonymName);
1290         assertNotNull(derivedUnitDeterminationOrphanName);
1291         assertNotNull(tissueUuidNoAssociation);
1292         assertNotNull(dnaSampleUuidIndividualsAssociation);
1293         assertNotNull(fossilTypeDesignation);
1294         assertNotNull(taxon);
1295         assertNotNull(synonym);
1296         assertNotNull(taxonName);
1297         assertNotNull(synonymName);
1298         assertNotNull(orphanName);
1299
1300         /*
1301          * search for taxon
1302          * should retrieve all specimens associated via
1303          *  - type designations (fossil)
1304          *  - individuals associations (dnaSample)
1305          *  - determinations on
1306          *   - taxon (specimenA)
1307          *   - taxon name (specimenA, specimenB)
1308          *   - synonym names (specimenC)
1309          */
1310         FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();
1311         config.setAssociatedTaxonUuid(taxonUuid);
1312         List<SpecimenOrObservationBase> specimens = occurrenceService.findByTitle(config).getRecords();
1313         assertTrue(specimens.contains(derivedUnitDeterminationName));
1314         assertTrue(specimens.contains(derivedUnitDeterminationTaxon));
1315         assertTrue(specimens.contains(derivedUnitDeterminationSynonymName));
1316         assertTrue(specimens.contains(dnaSampleUuidIndividualsAssociation));
1317         assertTrue(specimens.contains(fossilTypeDesignation));
1318         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1319         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1320         assertEquals("Wrong number of associated specimens", 5, specimens.size());
1321
1322         /*
1323          * search for taxon name
1324          * should retrieve all specimens associated via
1325          *  - determinations on
1326          *   - taxon name (specimenA, specimenB)
1327          */
1328         config = new FindOccurrencesConfigurator();
1329         config.setAssociatedTaxonNameUuid(taxonNameUuid);
1330         specimens = occurrenceService.findByTitle(config).getRecords();
1331         assertTrue(specimens.contains(derivedUnitDeterminationName));
1332         assertTrue(specimens.contains(derivedUnitDeterminationTaxon));
1333         assertTrue(!specimens.contains(derivedUnitDeterminationSynonymName));
1334         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1335         assertTrue(!specimens.contains(fossilTypeDesignation));
1336         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1337         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1338         assertEquals("Wrong number of associated specimens", 2, specimens.size());
1339
1340         /*
1341          * search for synonym name
1342          * should retrieve all specimens associated via
1343          *  - determinations on
1344          *   - synonym names (specimenC)
1345          */
1346         config = new FindOccurrencesConfigurator();
1347         config.setAssociatedTaxonNameUuid(synonymNameUuid);
1348         specimens = occurrenceService.findByTitle(config).getRecords();
1349         assertTrue(!specimens.contains(derivedUnitDeterminationName));
1350         assertTrue(!specimens.contains(derivedUnitDeterminationTaxon));
1351         assertTrue(specimens.contains(derivedUnitDeterminationSynonymName));
1352         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1353         assertTrue(!specimens.contains(fossilTypeDesignation));
1354         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1355         assertTrue(!specimens.contains(derivedUnitDeterminationOrphanName));
1356         assertEquals("Wrong number of associated specimens", 1, specimens.size());
1357
1358         /*
1359          * search for orphan name
1360          * should retrieve all specimens associated via
1361          *  - determinations on
1362          *   - taxon name (specimenD)
1363          */
1364         config = new FindOccurrencesConfigurator();
1365         config.setAssociatedTaxonNameUuid(orphanNameUuid);
1366         specimens = occurrenceService.findByTitle(config).getRecords();
1367         assertTrue(!specimens.contains(derivedUnitDeterminationName));
1368         assertTrue(!specimens.contains(derivedUnitDeterminationTaxon));
1369         assertTrue(!specimens.contains(derivedUnitDeterminationSynonymName));
1370         assertTrue(!specimens.contains(dnaSampleUuidIndividualsAssociation));
1371         assertTrue(!specimens.contains(fossilTypeDesignation));
1372         assertTrue(!specimens.contains(tissueUuidNoAssociation));
1373         assertTrue(specimens.contains(derivedUnitDeterminationOrphanName));
1374         assertEquals("Wrong number of associated specimens", 1, specimens.size());
1375
1376 //        //DERIVATIVES
1377 //        //determination: taxon
1378 //        DerivedUnit derivedUnitDeterminationTaxon = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1379 //        derivedUnitDeterminationTaxon.setTitleCache("Derived Unit determined as taxon");
1380 //        //determination: taxon name
1381 //        DerivedUnit derivedUnitDeterminationName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1382 //        derivedUnitDeterminationName.setTitleCache("Derived Unit determined as name");
1383 //        //determination: synonym
1384 //        DerivedUnit derivedUnitDeterminationSynonym = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1385 //        derivedUnitDeterminationSynonym.setTitleCache("Derived Unit determined as synonym");
1386 //        //determination: synonym name
1387 //        DerivedUnit derivedUnitDeterminationSynonymName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1388 //        derivedUnitDeterminationSynonymName.setTitleCache("Derived Unit determined as synonym name");
1389 //        //determination: orphan name
1390 //        DerivedUnit derivedUnitDeterminationOrphanName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1391 //        derivedUnitDeterminationOrphanName.setTitleCache("Derived Unit determined as orphan name");
1392 //        //no association
1393 //        DerivedUnit tissueUuidNoAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
1394 //        tissueUuidNoAssociation.setTitleCache("tissue sample no association");
1395 //        //individuals association with taxon
1396 //        DerivedUnit dnaSampleUuidIndividualsAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
1397 //        dnaSampleUuidIndividualsAssociation.setTitleCache("dna associated via IndividualsAssociation");
1398 //        //type specimen of taxon
1399 //        DerivedUnit fossilTypeDesignation = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
1400 //        fossilTypeDesignation.setTitleCache("Fossil with type designation");
1401 //
1402 //        derivedUnitDeterminationTaxon.setUuid(derivedUnitDeterminationTaxonUuid);
1403 //        derivedUnitDeterminationName.setUuid(derivedUnitDeterminationNameUuid);
1404 //        derivedUnitDeterminationSynonym.setUuid(derivedUnitDeterminationSynonymUuid);
1405 //        derivedUnitDeterminationSynonymName.setUuid(derivedUnitDeterminationSynonymNameUuid);
1406 //        derivedUnitDeterminationOrphanName.setUuid(derivedUnitDeterminationOrphanNameUuid);
1407 //        tissueUuidNoAssociation.setUuid(tissueUuidNoAssociationUuid);
1408 //        dnaSampleUuidIndividualsAssociation.setUuid(dnaSampleUuidIndividualsAssociationUuid);
1409 //        fossilTypeDesignation.setUuid(fossilTypeDesignationUuid);
1410 //
1411 //        occurrenceService.save(derivedUnitDeterminationTaxon);
1412 //        occurrenceService.save(derivedUnitDeterminationName);
1413 //        occurrenceService.save(derivedUnitDeterminationSynonym);
1414 //        occurrenceService.save(derivedUnitDeterminationSynonymName);
1415 //        occurrenceService.save(derivedUnitDeterminationOrphanName);
1416 //        occurrenceService.save(tissueUuidNoAssociation);
1417 //        occurrenceService.save(dnaSampleUuidIndividualsAssociation);
1418 //        occurrenceService.save(fossilTypeDesignation);
1419 //
1420 //        //NAMES
1421 //        TaxonName taxonName = TaxonNameFactory.PARSED_BOTANICAL("Campanula patual");
1422 //        TaxonName synonymName = TaxonNameFactory.PARSED_BOTANICAL("Syno nyma");
1423 //        TaxonName orphanName = TaxonNameFactory.PARSED_BOTANICAL("Orphanus lonelia");
1424 //        taxonName.setUuid(taxonNameUuid);
1425 //        synonymName.setUuid(synonymNameUuid);
1426 //        orphanName.setUuid(orphanNameUuid);
1427 //
1428 //        //TAXON
1429 //        Taxon taxon = Taxon.NewInstance(taxonName, null);
1430 //        taxon.setUuid(taxonUuid);
1431 //
1432 //        Classification classification = Classification.NewInstance("Test Classification");
1433 //        TaxonNode taxonNode = classification.addChildTaxon(taxon, null, null);
1434 //        taxonNode.setUuid(taxonNodeUuid);
1435 //
1436 //        //SYNONYM
1437 //        Synonym synonym = Synonym.NewInstance(synonymName, null);
1438 //        synonym.setUuid(synoymUuid);
1439 //        taxon.addSynonym(synonym, SynonymType.HOMOTYPIC_SYNONYM_OF());
1440 //
1441 //        //IndividualsAssociation
1442 //        TaxonDescription taxonDescription = TaxonDescription.NewInstance();
1443 //        IndividualsAssociation association = IndividualsAssociation.NewInstance(dnaSampleUuidIndividualsAssociation);
1444 //        association.setFeature(Feature.SPECIMEN());
1445 //        taxonDescription.addElement(association);
1446 //        taxon.addDescription(taxonDescription);
1447 //
1448 //        //DETERMINATION EVENTS
1449 //        DeterminationEvent.NewInstance(taxon, derivedUnitDeterminationTaxon);
1450 //        DeterminationEvent.NewInstance(taxonName, derivedUnitDeterminationName);
1451 //        //        DeterminationEvent.NewInstance(synonym, derivedUnitDeterminationSynonym);//TODO determinationa on synonym not possible?
1452 //        DeterminationEvent.NewInstance(synonymName, derivedUnitDeterminationSynonymName);
1453 //        DeterminationEvent.NewInstance(orphanName, derivedUnitDeterminationOrphanName);
1454 //
1455 //        //type designation
1456 //        SpecimenTypeDesignation specimenTypeDesignation = SpecimenTypeDesignation.NewInstance();
1457 //        specimenTypeDesignation.setTypeSpecimen(fossilTypeDesignation);
1458 //        taxonName.addTypeDesignation(specimenTypeDesignation, false);
1459 //
1460 //        classificationService.save(classification);
1461 //        taxonService.saveOrUpdate(taxon);
1462 //        taxonNodeService.save(taxonNode);
1463 //
1464 //        commitAndStartNewTransaction(null);
1465 //
1466 //        setComplete();
1467 //        endTransaction();
1468 //
1469 //
1470 //        try {
1471 //            writeDbUnitDataSetFile(new String[] {
1472 //        "SpecimenOrObservationBase",
1473 //        "SpecimenOrObservationBase_DerivationEvent",
1474 //        "DerivationEvent",
1475 //        "DescriptionElementBase",
1476 //        "DescriptionBase",
1477 //        "TaxonBase",
1478 //        "TaxonNode",
1479 //        "Classification",
1480 //        "TypeDesignationBase",
1481 //        "TaxonName",
1482 //        "TaxonName_TypeDesignationBase",
1483 //        "HomotypicalGroup",
1484 //        "TeamOrPersonBase",
1485 //        "LanguageString",
1486 //        "DeterminationEvent"
1487 //            }, "testAllKindsOfSpecimenAssociations");
1488 //        } catch (FileNotFoundException e) {
1489 //            e.printStackTrace();
1490 //        }
1491
1492
1493     }
1494
1495     @Test
1496     @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "OccurrenceServiceTest.testDnaSampleDesignation.xml")
1497     public void testDnaSampleDesignation(){
1498         DefinedTerm sampleDesignationTermType = (DefinedTerm) termService.load(UUID.fromString("fadeba12-1be3-4bc7-9ff5-361b088d86fc"));
1499
1500         UUID dnaSampleUuid = UUID.fromString("4bee91b9-23d8-438b-8569-6d6aaa5b6587");
1501         DnaSample dnaSample = HibernateProxyHelper.deproxy(occurrenceService.load(dnaSampleUuid), DnaSample.class);
1502         assertEquals(1, dnaSample.getIdentifiers().size());
1503         Identifier<?> identifier = dnaSample.getIdentifiers().iterator().next();
1504         assertEquals("NK 2088", identifier.getIdentifier());
1505         assertEquals(sampleDesignationTermType, identifier.getType());
1506
1507         //change identifier, save and reload
1508         identifier.setIdentifier("WB10");
1509         occurrenceService.saveOrUpdate(dnaSample);
1510         SpecimenOrObservationBase<?> dnaSampleReloaded = occurrenceService.load(dnaSampleUuid);
1511         assertEquals(1, dnaSample.getIdentifiers().size());
1512         Identifier<?> identifierReloaded = dnaSample.getIdentifiers().iterator().next();
1513         assertEquals("WB10", identifierReloaded.getIdentifier());
1514         assertEquals(sampleDesignationTermType, identifierReloaded.getType());
1515
1516
1517 //        DefinedTerm sampleDesignationTermType = (DefinedTerm) termService.load(UUID.fromString("fadeba12-1be3-4bc7-9ff5-361b088d86fc"));
1518 //        //UUIDS
1519 //        UUID dnaSampleUuid = UUID.fromString("4bee91b9-23d8-438b-8569-6d6aaa5b6587");
1520 //        DerivedUnit dnaSample = DnaSample.NewInstance();
1521 //        dnaSample.setUuid(dnaSampleUuid);
1522 //        Identifier.NewInstance(dnaSample, "NK 2088", sampleDesignationTermType);
1523 //
1524 //        occurrenceService.save(dnaSample);
1525 //
1526 //        commitAndStartNewTransaction(null);
1527 //
1528 //        setComplete();
1529 //        endTransaction();
1530 //
1531 //
1532 //        try {
1533 //            writeDbUnitDataSetFile(new String[] {
1534 //                    "SpecimenOrObservationBase",
1535 //                    "IDENTIFIER",
1536 //                    "SpecimenOrObservationBase_Identifier"
1537 //            }, "testDnaSampleDesignation");
1538 //        } catch (FileNotFoundException e) {
1539 //            e.printStackTrace();
1540 //        }
1541     }
1542     @Override
1543 //  @Test
1544   public void createTestDataSet() throws FileNotFoundException {
1545       //UUIDS
1546       UUID derivedUnitDeterminationTaxonUuid = UUID.fromString("941b8b22-1925-4b91-8ff8-97114499bb22");
1547       UUID derivedUnitDeterminationNameUuid = UUID.fromString("0cdc7a57-6f55-45c8-b3e5-523748c381e7");
1548
1549       UUID derivedUnitDeterminationSynonymUuid = UUID.fromString("8eb94a7d-c802-49a7-bc10-c26de20a52c2");
1550       UUID derivedUnitDeterminationSynonymNameUuid = UUID.fromString("d940a940-8caf-4a52-b1d8-ba4aad7ddae2");
1551
1552       UUID derivedUnitDeterminationOrphanNameUuid = UUID.fromString("587b7297-7d59-4f59-8ef3-c7a559cadeca");
1553
1554       UUID tissueUuidNoAssociationUuid = UUID.fromString("93e94260-5107-4b2c-9ce4-da9e1a4e7cb9");
1555       UUID dnaSampleUuidIndividualsAssociationUuid = UUID.fromString("1fb53903-c9b9-4078-8297-5b86aec7fe21");
1556       UUID fossilTypeDesignationUuid = UUID.fromString("42ec8dcf-a923-4256-bbd5-b0d10f4de5e2");
1557
1558       UUID taxonNodeUuid = UUID.fromString("6b8b6ff9-66e4-4496-8e5a-7d03bdf9a076");
1559       UUID taxonUuid = UUID.fromString("07cc47a5-1a63-46a1-8366-0d59d2b90d5b");
1560       UUID synoymUuid = UUID.fromString("c16bcd9b-7d18-4fb5-af60-f9ef14c1d3a9");
1561
1562       UUID taxonNameUuid = UUID.fromString("e59b95c0-9ad6-48be-af62-a982ba72b917");
1563       UUID synonymNameUuid = UUID.fromString("39f04b2a-b8bd-46e8-9102-ab665c64ec8e");
1564       UUID orphanNameUuid = UUID.fromString("d8e56365-3ad9-4b0e-88bf-acaaab223a9b");
1565
1566       //DERIVATIVES
1567       //determination: taxon
1568       DerivedUnit derivedUnitDeterminationTaxon = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1569       derivedUnitDeterminationTaxon.setTitleCache("Derived Unit determined as taxon");
1570       //determination: taxon name
1571       DerivedUnit derivedUnitDeterminationName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1572       derivedUnitDeterminationName.setTitleCache("Derived Unit determined as name");
1573       //determination: synonym
1574       DerivedUnit derivedUnitDeterminationSynonym = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1575       derivedUnitDeterminationSynonym.setTitleCache("Derived Unit determined as synonym");
1576       //determination: synonym name
1577       DerivedUnit derivedUnitDeterminationSynonymName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1578       derivedUnitDeterminationSynonymName.setTitleCache("Derived Unit determined as synonym name");
1579       //determination: orphan name
1580       DerivedUnit derivedUnitDeterminationOrphanName = DerivedUnit.NewInstance(SpecimenOrObservationType.PreservedSpecimen);
1581       derivedUnitDeterminationOrphanName.setTitleCache("Derived Unit determined as orphan name");
1582       //no association
1583       DerivedUnit tissueUuidNoAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.TissueSample);
1584       tissueUuidNoAssociation.setTitleCache("tissue sample no association");
1585       //individuals association with taxon
1586       DerivedUnit dnaSampleUuidIndividualsAssociation = DerivedUnit.NewInstance(SpecimenOrObservationType.DnaSample);
1587       dnaSampleUuidIndividualsAssociation.setTitleCache("dna associated via IndividualsAssociation");
1588       //type specimen of taxon
1589       DerivedUnit fossilTypeDesignation = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
1590       fossilTypeDesignation.setTitleCache("Fossil with type designation");
1591
1592       derivedUnitDeterminationTaxon.setUuid(derivedUnitDeterminationTaxonUuid);
1593       derivedUnitDeterminationName.setUuid(derivedUnitDeterminationNameUuid);
1594       derivedUnitDeterminationSynonym.setUuid(derivedUnitDeterminationSynonymUuid);
1595       derivedUnitDeterminationSynonymName.setUuid(derivedUnitDeterminationSynonymNameUuid);
1596       derivedUnitDeterminationOrphanName.setUuid(derivedUnitDeterminationOrphanNameUuid);
1597       tissueUuidNoAssociation.setUuid(tissueUuidNoAssociationUuid);
1598       dnaSampleUuidIndividualsAssociation.setUuid(dnaSampleUuidIndividualsAssociationUuid);
1599       fossilTypeDesignation.setUuid(fossilTypeDesignationUuid);
1600
1601       occurrenceService.save(derivedUnitDeterminationTaxon);
1602       occurrenceService.save(derivedUnitDeterminationName);
1603       occurrenceService.save(derivedUnitDeterminationSynonym);
1604       occurrenceService.save(derivedUnitDeterminationSynonymName);
1605       occurrenceService.save(derivedUnitDeterminationOrphanName);
1606       occurrenceService.save(tissueUuidNoAssociation);
1607       occurrenceService.save(dnaSampleUuidIndividualsAssociation);
1608       occurrenceService.save(fossilTypeDesignation);
1609
1610       //NAMES
1611       TaxonName taxonName = TaxonNameFactory.PARSED_BOTANICAL("Campanula patual");
1612       TaxonName synonymName = TaxonNameFactory.PARSED_BOTANICAL("Syno nyma");
1613       TaxonName orphanName = TaxonNameFactory.PARSED_BOTANICAL("Orphanus lonelia");
1614       taxonName.setUuid(taxonNameUuid);
1615       synonymName.setUuid(synonymNameUuid);
1616       orphanName.setUuid(orphanNameUuid);
1617
1618       //TAXON
1619       Taxon taxon = Taxon.NewInstance(taxonName, null);
1620       taxon.setUuid(taxonUuid);
1621
1622       Classification classification = Classification.NewInstance("Test Classification");
1623       TaxonNode taxonNode = classification.addChildTaxon(taxon, null, null);
1624       taxonNode.setUuid(taxonNodeUuid);
1625
1626       //SYNONYM
1627       Synonym synonym = Synonym.NewInstance(synonymName, null);
1628       synonym.setUuid(synoymUuid);
1629       taxon.addSynonym(synonym, SynonymType.HOMOTYPIC_SYNONYM_OF());
1630
1631       //IndividualsAssociation
1632       TaxonDescription taxonDescription = TaxonDescription.NewInstance();
1633       IndividualsAssociation association = IndividualsAssociation.NewInstance(dnaSampleUuidIndividualsAssociation);
1634       association.setFeature(Feature.SPECIMEN());
1635       taxonDescription.addElement(association);
1636       taxon.addDescription(taxonDescription);
1637
1638       //DETERMINATION EVENTS
1639       DeterminationEvent.NewInstance(taxon, derivedUnitDeterminationTaxon);
1640       DeterminationEvent.NewInstance(taxonName, derivedUnitDeterminationName);
1641       //        DeterminationEvent.NewInstance(synonym, derivedUnitDeterminationSynonym);//TODO determinationa on synonym not possible?
1642       DeterminationEvent.NewInstance(synonymName, derivedUnitDeterminationSynonymName);
1643       DeterminationEvent.NewInstance(orphanName, derivedUnitDeterminationOrphanName);
1644
1645       //type designation
1646       SpecimenTypeDesignation specimenTypeDesignation = SpecimenTypeDesignation.NewInstance();
1647       specimenTypeDesignation.setTypeSpecimen(fossilTypeDesignation);
1648       taxonName.addTypeDesignation(specimenTypeDesignation, false);
1649
1650       classificationService.saveOrUpdate(classification);
1651       taxonService.saveOrUpdate(taxon);
1652       taxonNodeService.saveOrUpdate(taxonNode);
1653
1654       commitAndStartNewTransaction(null);
1655
1656       setComplete();
1657       endTransaction();
1658
1659
1660       try {
1661           writeDbUnitDataSetFile(new String[] {
1662                   "SpecimenOrObservationBase",
1663                   "SpecimenOrObservationBase_DerivationEvent",
1664                   "DerivationEvent",
1665                   "DescriptionElementBase",
1666                   "DescriptionBase",
1667                   "TaxonBase",
1668                   "TaxonNode",
1669                   "Classification",
1670                   "TypeDesignationBase",
1671                   "TaxonName",
1672                   "TaxonName_TypeDesignationBase",
1673                   "HomotypicalGroup",
1674                   "TeamOrPersonBase",
1675                   "LanguageString",
1676                   "DeterminationEvent"
1677           }, "testAllKindsOfSpecimenAssociations");
1678       } catch (FileNotFoundException e) {
1679           e.printStackTrace();
1680       }
1681
1682   }
1683 }