cdmlib-services/src/test/java/eu/etaxonomy/cdm/api/service/OccurrenceServiceDeepDeleteTest.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.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.io.FileNotFoundException;
  16 import java.util.UUID;
  17
  18 import org.apache.logging.log4j.LogManager;
  19 import org.apache.logging.log4j.Logger;
  20 import org.junit.Test;
  21 import org.unitils.dbunit.annotation.DataSet;
  22 import org.unitils.spring.annotation.SpringBeanByType;
  23
  24 import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;
  25 import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
  26 import eu.etaxonomy.cdm.api.service.pager.Pager;
  27 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  28 import eu.etaxonomy.cdm.model.molecular.Sequence;
  29 import eu.etaxonomy.cdm.model.molecular.SingleRead;
  30 import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment;
  31 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  32 import eu.etaxonomy.cdm.model.name.Rank;
  33 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
  34 import eu.etaxonomy.cdm.model.name.TaxonName;
  35 import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
  36 import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
  37 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  38 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  39 import eu.etaxonomy.cdm.model.occurrence.GatheringEvent;
  40 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  41 import eu.etaxonomy.cdm.persistence.dao.molecular.ISingleReadDao;
  42 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  43 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  44
  45 /**
  46  * @author pplitzner
  47  * @since 31.03.2014
  48  */
  49 public class OccurrenceServiceDeepDeleteTest extends CdmTransactionalIntegrationTest {
  50
  51     @SuppressWarnings("unused")
  52     private static final Logger logger = LogManager.getLogger();
  53
  54     private final UUID FIELD_UNIT_UUID = UUID.fromString("b5f58da5-4442-4001-9d13-33f41518b72a");
  55     private final UUID DERIVED_UNIT_UUID = UUID.fromString("448be6e7-f19c-4a10-9a0a-97aa005f817d");
  56     private final UUID DNA_SAMPLE_UUID = UUID.fromString("bee4212b-aff1-484e-845f-065c7d6216af");
  57     private final UUID SEQUENCE_UUID = UUID.fromString("0b867369-de8c-4837-a708-5b7d9f6091be");
  58     private final UUID FIELD_UNIT2_UUID = UUID.fromString("ae798108-6483-4d09-900f-7f849c43bcc9");
  59
  60     @SpringBeanByType
  61     private IOccurrenceService occurrenceService;
  62
  63     @SpringBeanByType
  64     private IEventBaseService eventService;
  65
  66     @SpringBeanByType
  67     private ISingleReadDao singleReadDao;
  68
  69     @SpringBeanByType
  70     private ISequenceService sequenceService;
  71
  72     @SpringBeanByType
  73     private INameService nameService;
  74
  75     @Test
  76     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceTest.testDeleteDerivateHierarchyStepByStep.xml")
  77     public void testDeepDelete_FieldUnit(){
  78
  79         String assertMessage = "Incorrect number of specimens after deletion.";
  80         DeleteResult deleteResult = null;
  81         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
  82         config.setDeleteMolecularData(true);
  83         config.setDeleteChildren(true);
  84
  85         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(FIELD_UNIT_UUID);
  86         GatheringEvent gatheringEvent = GatheringEvent.NewInstance();
  87         fieldUnit.setGatheringEvent(gatheringEvent);
  88         FieldUnit fieldUnit2 = (FieldUnit) occurrenceService.load(FIELD_UNIT2_UUID);
  89         fieldUnit2.setGatheringEvent(gatheringEvent);
  90         DnaSample dnaSample = (DnaSample) occurrenceService.load(DNA_SAMPLE_UUID);
  91
  92         //check initial state
  93         assertEquals(assertMessage, 6, occurrenceService.count(SpecimenOrObservationBase.class));
  94         assertEquals(assertMessage, 4, eventService.count(DerivationEvent.class));
  95         assertEquals(assertMessage, 2, occurrenceService.count(FieldUnit.class));
  96         assertEquals(assertMessage, 4, occurrenceService.count(DerivedUnit.class));
  97         assertEquals(assertMessage, 2, occurrenceService.count(DnaSample.class));
  98         assertEquals("incorrect number of amplification results", 1, dnaSample.getAmplificationResults().size());
  99         assertEquals("number of sequences incorrect", 1, dnaSample.getSequences().size());
 100         assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 101         assertEquals("incorrect number of gathering events", 1, eventService.count(GatheringEvent.class));
 102         //delete field unit
 103         deleteResult = occurrenceService.delete(fieldUnit, config);
 104         assertTrue(deleteResult.toString(), deleteResult.isOk());
 105         assertEquals(assertMessage, 2, eventService.count(DerivationEvent.class));
 106         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 107         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 108         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 109         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 110         assertEquals("incorrect number of gathering events", 1, eventService.count(GatheringEvent.class));
 111
 112         deleteResult = occurrenceService.delete(fieldUnit2, config);
 113         assertEquals(assertMessage, 0, eventService.count(GatheringEvent.class));
 114     }
 115
 116     @Test
 117     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceTest.testDeleteDerivateHierarchyStepByStep.xml")
 118     public void testDeepDelete_FieldUnitWithTypeDesignation(){
 119
 120
 121         String assertMessage = "Incorrect number of specimens after deletion.";
 122         DeleteResult deleteResult = null;
 123         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 124         config.setDeleteMolecularData(true);
 125         config.setDeleteChildren(true);
 126         config.setDeleteFromTypeDesignation(true);
 127
 128         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(FIELD_UNIT_UUID);
 129         DnaSample dnaSample = (DnaSample) occurrenceService.load(DNA_SAMPLE_UUID);
 130         TaxonName name = TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SPECIES(), "Test", null, "test", null, null, null, null, null);
 131         SpecimenTypeDesignation specimenTypeDesignation = SpecimenTypeDesignation.NewInstance();
 132         specimenTypeDesignation.setTypeSpecimen(dnaSample);
 133         name.addTypeDesignation(specimenTypeDesignation, false);
 134         nameService.save(name);
 135         Pager<TypeDesignationBase> typeDesignations = nameService.getTypeDesignations(name, null, 100, 0);
 136         Long oldCount= typeDesignations.getCount();
 137         //check initial state
 138         assertEquals(assertMessage, 6, occurrenceService.count(SpecimenOrObservationBase.class));
 139         assertEquals(assertMessage, 4, eventService.count(DerivationEvent.class));
 140         assertEquals(assertMessage, 2, occurrenceService.count(FieldUnit.class));
 141         assertEquals(assertMessage, 4, occurrenceService.count(DerivedUnit.class));
 142         assertEquals(assertMessage, 2, occurrenceService.count(DnaSample.class));
 143         assertEquals("incorrect number of amplification results", 1, dnaSample.getAmplificationResults().size());
 144         assertEquals("number of sequences incorrect", 1, dnaSample.getSequences().size());
 145         assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 146
 147         //delete field unit
 148         deleteResult = occurrenceService.delete(fieldUnit, config);
 149         assertTrue(deleteResult.toString(), deleteResult.isOk());
 150         assertEquals(assertMessage, 2, eventService.count(DerivationEvent.class));
 151         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 152         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 153         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 154         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 155         typeDesignations = nameService.getTypeDesignations(name, null, 100, 0);
 156         Long afterDeleteCount= typeDesignations.getCount();
 157         assertTrue(oldCount > afterDeleteCount);
 158     }
 159
 160     @Test
 161     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 162     public void testDeepDelete_DerivedUnit(){
 163         String assertMessage = "Incorrect number of specimens after deletion.";
 164         DeleteResult deleteResult = null;
 165         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 166         config.setDeleteMolecularData(true);
 167         config.setDeleteChildren(true);
 168
 169         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(DERIVED_UNIT_UUID);
 170         DnaSample dnaSample = (DnaSample) occurrenceService.load(DNA_SAMPLE_UUID);
 171
 172         //check initial state
 173         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 174         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 175         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 176         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 177         assertEquals("incorrect number of amplification results", 1, dnaSample.getAmplificationResults().size());
 178         assertEquals("number of sequences incorrect", 1, dnaSample.getSequences().size());
 179         assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 180
 181         //delete derived unit
 182         deleteResult = occurrenceService.delete(derivedUnit, config);
 183         assertTrue(deleteResult.toString(), deleteResult.isOk());
 184         assertEquals(assertMessage, 1, occurrenceService.count(SpecimenOrObservationBase.class));
 185         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 186         assertEquals(assertMessage, 0, occurrenceService.count(DerivedUnit.class));
 187         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 188     }
 189
 190     @Test
 191     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
 192     public void testDeepDelete_DnaSample(){
 193         String assertMessage = "Incorrect number of specimens after deletion.";
 194         DeleteResult deleteResult = null;
 195         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 196         config.setDeleteMolecularData(true);
 197         config.setDeleteChildren(true);
 198
 199         DnaSample dnaSample = (DnaSample) occurrenceService.load(DNA_SAMPLE_UUID);
 200
 201         //check initial state
 202         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 203         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 204         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 205         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 206         assertEquals("incorrect number of amplification results", 1, dnaSample.getAmplificationResults().size());
 207         assertEquals("number of sequences incorrect", 1, dnaSample.getSequences().size());
 208         assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 209
 210         //delete dna sample
 211         deleteResult = occurrenceService.delete(dnaSample, config);
 212         assertTrue(deleteResult.toString(), deleteResult.isOk());
 213         assertEquals(assertMessage, 2, occurrenceService.count(SpecimenOrObservationBase.class));
 214         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 215         assertEquals(assertMessage, 1, occurrenceService.count(DerivedUnit.class));
 216         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 217     }
 218
 219     @Test
 220     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceDeepDeleteTest.testDeepDelete_SingleRead.xml")
 221     public void testDeepDelete_SingleRead(){
 222         UUID sequenceA1Uuid = UUID.fromString("3db46d26-94ef-4759-aad8-42d0b9aea9b6");
 223         UUID sequenceA2Uuid = UUID.fromString("afa3771c-2b9d-46d7-82e0-8b9c050706e3");
 224         UUID sequenceB1Uuid = UUID.fromString("d7199db5-708e-470a-a573-9c760dd07cd1");
 225         UUID sequenceB2Uuid = UUID.fromString("1cb83575-38ea-4a8c-9418-d87163f425ce");
 226         UUID singleReadAUuid = UUID.fromString("82f538a1-2274-4d55-b27b-ed2f004ab5cd");
 227         UUID singleReadBUuid = UUID.fromString("fc74199a-89dc-40a0-9cbd-08cebebff4b5");
 228
 229         //how the XML was generated
 230 //        Sequence sequenceA1 = Sequence.NewInstance("A");
 231 //        Sequence sequenceA2 = Sequence.NewInstance("T");
 232 //        Sequence sequenceB1 = Sequence.NewInstance("C");
 233 //        Sequence sequenceB2 = Sequence.NewInstance("G");
 234 //
 235 //        SingleRead singleReadA = SingleRead.NewInstance();
 236 //        SingleRead singleReadB = SingleRead.NewInstance();
 237 //
 238 //        sequenceA1.setUuid(sequenceA1Uuid);
 239 //        sequenceA2.setUuid(sequenceA2Uuid);
 240 //        sequenceB1.setUuid(sequenceB1Uuid);
 241 //        sequenceB1.setUuid(sequenceB2Uuid);
 242 //        singleReadA.setUuid(singleReadAUuid);
 243 //        singleReadB.setUuid(singleReadBUuid);
 244 //
 245 //        SingleReadAlignment.NewInstance(sequenceA1, singleReadA);
 246 //        SingleReadAlignment.NewInstance(sequenceA2, singleReadA);
 247 //        SingleReadAlignment.NewInstance(sequenceB1, singleReadB);
 248 //        SingleReadAlignment.NewInstance(sequenceB2, singleReadB);
 249 //
 250 //        sequenceService.save(sequenceA1);
 251 //        sequenceService.save(sequenceA2);
 252 //        sequenceService.save(sequenceB1);
 253 //        sequenceService.save(sequenceB2);
 254 //
 255 //        commitAndStartNewTransaction(null);
 256 //
 257 //        setComplete();
 258 //        endTransaction();
 259 //
 260 //        try {
 261 //            writeDbUnitDataSetFile(new String[] {
 262 //                    "SpecimenOrObservationBase",
 263 //                    "SpecimenOrObservationBase_DerivationEvent",
 264 //                    "DerivationEvent",
 265 //                    "Sequence",
 266 //                    "SingleRead",
 267 //                    "SingleReadAlignment",
 268 //                    "Amplification",
 269 //                    "AmplificationResult",
 270 //                    "DescriptionElementBase",
 271 //                    "DescriptionBase",
 272 //                    "TaxonBase",
 273 //                    "TypeDesignationBase",
 274 //                    "TaxonName",
 275 //                    "TaxonName_TypeDesignationBase",
 276 //                    "HomotypicalGroup"
 277 //            }, "testDeepDelete_SingleRead");
 278 //        } catch (FileNotFoundException e) {
 279 //            e.printStackTrace();
 280 //        }
 281
 282         DeleteResult deleteResult = null;
 283         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 284         config.setDeleteMolecularData(true);
 285         config.setDeleteChildren(true);
 286
 287         Sequence sequenceA1 = sequenceService.load(sequenceA1Uuid);
 288         Sequence sequenceA2 = sequenceService.load(sequenceA2Uuid);
 289         Sequence sequenceB1 = sequenceService.load(sequenceB1Uuid);
 290         Sequence sequenceB2 = sequenceService.load(sequenceB2Uuid);
 291         SingleRead singleReadA = singleReadDao.load(singleReadAUuid);
 292         SingleRead singleReadB = singleReadDao.load(singleReadBUuid);
 293
 294         //check initial state
 295         assertNotNull(sequenceA1);
 296         assertNotNull(sequenceA2);
 297         assertNotNull(sequenceB1);
 298         assertNotNull(sequenceB2);
 299         assertNotNull(singleReadA);
 300         assertNotNull(singleReadB);
 301         assertEquals("number of sequences incorrect", 4, sequenceService.count(Sequence.class));
 302         assertEquals("incorrect number of single reads", 2, singleReadDao.count());
 303
 304         //A: delete singleRead
 305         //delete singleReadA from sequenceA1 (singleReadA should NOT be deleted)
 306         deleteResult = sequenceService.deleteSingleRead(singleReadA, sequenceA1);
 307         assertTrue(deleteResult.toString(), deleteResult.isOk());
 308         assertEquals("incorrect number of single reads", 2, singleReadDao.count());
 309         assertEquals(0, sequenceA1.getSingleReadAlignments().size());
 310         assertNotNull(singleReadDao.load(singleReadAUuid));
 311
 312         //delete singleReadA from sequenceA2 (singleReadA should be deleted)
 313         deleteResult = sequenceService.deleteSingleRead(singleReadA, sequenceA2);
 314         assertTrue(deleteResult.toString(), deleteResult.isOk());
 315         assertEquals("incorrect number of single reads", 1, singleReadDao.count());
 316         assertEquals(0, sequenceA2.getSingleReadAlignments().size());
 317         assertTrue(singleReadDao.load(singleReadAUuid)==null);
 318
 319         //B: delete sequence
 320         //delete sequenceB1 (singleReadB should NOT be deleted)
 321         deleteResult = sequenceService.delete(sequenceB1Uuid);
 322         assertTrue(deleteResult.toString(), deleteResult.isOk());
 323         assertEquals("incorrect number of single reads", 1, singleReadDao.count());
 324         assertNotNull(singleReadDao.load(singleReadBUuid));
 325
 326         //delete sequenceB1 (singleReadB should be deleted)
 327         deleteResult = sequenceService.delete(sequenceB2Uuid);
 328         assertTrue(deleteResult.toString(), deleteResult.isOk());
 329         assertEquals("incorrect number of single reads", 0, singleReadDao.count());
 330         assertTrue(singleReadDao.load(singleReadBUuid)==null);
 331     }
 332
 333     @Test
 334     @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="OccurrenceServiceDeepDeleteTest.testDeepDelete_FieldUnitWithSiblingDerivatives.xml")
 335     public void testDeepDelete_FieldUnitWithSiblingDerivatives(){
 336         String assertMessage = "Incorrect number of specimens after deletion.";
 337         DeleteResult deleteResult = null;
 338         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 339         config.setDeleteChildren(true);
 340
 341         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(FIELD_UNIT_UUID);
 342
 343         //check initial state
 344         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 345         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 346         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 347         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 348
 349         //delete field unit
 350         deleteResult = occurrenceService.delete(fieldUnit, config);
 351         assertTrue(deleteResult.toString(), deleteResult.isOk());
 352         assertEquals(assertMessage, 0, occurrenceService.count(SpecimenOrObservationBase.class));
 353         assertEquals(assertMessage, 0, occurrenceService.count(FieldUnit.class));
 354         assertEquals(assertMessage, 0, occurrenceService.count(DerivedUnit.class));
 355         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 356     }
 357
 358
 359     @Test
 360     @DataSet(value="OccurrenceServiceDeepDeleteTest.testDeleteStepByStep.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 361     public void testDeleteDerivateHierarchyStepByStep(){
 362         UUID fieldUnitUuid = UUID.fromString("4d91a9bc-2af7-40f8-b6e6-545305301807");
 363         UUID derivedUnitUuid = UUID.fromString("f9c57904-e512-4927-90ad-f3833cdef967");
 364         UUID tissueSampleUuid = UUID.fromString("14b92fce-1236-455b-ba46-2a7e35d9230e");
 365         UUID dnaSampleUuid = UUID.fromString("60c31688-edec-4796-aa2f-28a7ea12256b");
 366         UUID sequenceUuid = UUID.fromString("24804b67-d6f7-48e5-811a-e7240230d305");
 367
 368         String assertMessage = "Incorrect number of specimens after deletion.";
 369         DeleteResult deleteResult = null;
 370         SpecimenDeleteConfigurator config = new SpecimenDeleteConfigurator();
 371
 372         FieldUnit fieldUnit = (FieldUnit) occurrenceService.load(fieldUnitUuid);
 373         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnitUuid);
 374         DerivedUnit tissueSample = (DerivedUnit) occurrenceService.load(tissueSampleUuid);
 375         DnaSample dnaSample = (DnaSample) occurrenceService.load(dnaSampleUuid);
 376         Sequence consensusSequence = sequenceService.load(sequenceUuid);
 377
 378         //check initial state
 379         assertNotNull(fieldUnit);
 380         assertNotNull(derivedUnit);
 381         assertNotNull(tissueSample);
 382         assertNotNull(dnaSample);
 383         assertNotNull(consensusSequence);
 384
 385         assertEquals(assertMessage, 4, occurrenceService.count(SpecimenOrObservationBase.class));
 386         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 387         assertEquals(assertMessage, 3, occurrenceService.count(DerivedUnit.class));
 388         assertEquals(assertMessage, 1, occurrenceService.count(DnaSample.class));
 389         assertEquals("incorrect number of amplification results", 1, dnaSample.getAmplificationResults().size());
 390         assertEquals("number of sequences incorrect", 1, dnaSample.getSequences().size());
 391         assertEquals("incorrect number of single reads", 1, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 392         assertEquals("incorrect number of single reads", 1, consensusSequence.getSingleReads().size());
 393         assertEquals(consensusSequence.getSingleReads().iterator().next(), dnaSample.getAmplificationResults().iterator().next().getSingleReads().iterator().next());
 394
 395         //allow deletion of molecular data
 396         config.setDeleteMolecularData(true);
 397
 398         SingleRead singleRead = dnaSample.getAmplificationResults().iterator().next().getSingleReads().iterator().next();
 399         deleteResult = sequenceService.deleteSingleRead(singleRead, consensusSequence);
 400         assertTrue(deleteResult.toString(), deleteResult.isOk());
 401         assertEquals("incorrect number of single reads", 0, dnaSample.getAmplificationResults().iterator().next().getSingleReads().size());
 402         assertEquals("incorrect number of single reads", 0, consensusSequence.getSingleReads().size());
 403         assertEquals("incorrect number of single reads", 0, singleReadDao.count());
 404
 405         //delete sequence
 406         deleteResult = sequenceService.delete(consensusSequence);
 407         assertTrue(deleteResult.toString(), deleteResult.isOk());
 408         assertEquals("number of sequences incorrect", 0, dnaSample.getSequences().size());
 409
 410
 411         //delete dna sample
 412         deleteResult = occurrenceService.delete(dnaSample, config);
 413         assertTrue(deleteResult.toString(), deleteResult.isOk());
 414         assertEquals(assertMessage, 3, occurrenceService.count(SpecimenOrObservationBase.class));
 415         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 416         assertEquals(assertMessage, 2, occurrenceService.count(DerivedUnit.class));
 417         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 418
 419         //delete tissue sample
 420         deleteResult = occurrenceService.delete(tissueSample, config);
 421         assertTrue(deleteResult.toString(), deleteResult.isOk());
 422         assertEquals(assertMessage, 2, occurrenceService.count(SpecimenOrObservationBase.class));
 423         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 424         assertEquals(assertMessage, 1, occurrenceService.count(DerivedUnit.class));
 425         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 426
 427         //delete derived unit
 428         deleteResult = occurrenceService.delete(derivedUnit, config);
 429         assertTrue(deleteResult.toString(), deleteResult.isOk());
 430         assertEquals(assertMessage, 1, occurrenceService.count(SpecimenOrObservationBase.class));
 431         assertEquals(assertMessage, 1, occurrenceService.count(FieldUnit.class));
 432         assertEquals(assertMessage, 0, occurrenceService.count(DerivedUnit.class));
 433         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 434
 435         //delete field unit
 436         deleteResult = occurrenceService.delete(fieldUnit, config);
 437
 438         assertTrue(deleteResult.toString(), deleteResult.isOk());
 439         assertEquals(assertMessage, 0, occurrenceService.count(SpecimenOrObservationBase.class));
 440         assertEquals(assertMessage, 0, occurrenceService.count(FieldUnit.class));
 441         assertEquals(assertMessage, 0, occurrenceService.count(DerivedUnit.class));
 442         assertEquals(assertMessage, 0, occurrenceService.count(DnaSample.class));
 443     }
 444
 445     @Override
 446 //    @Test
 447     public void createTestDataSet() throws FileNotFoundException {
 448         UUID sequenceA1Uuid = UUID.fromString("3db46d26-94ef-4759-aad8-42d0b9aea9b6");
 449         UUID sequenceA2Uuid = UUID.fromString("afa3771c-2b9d-46d7-82e0-8b9c050706e3");
 450         UUID sequenceB1Uuid = UUID.fromString("d7199db5-708e-470a-a573-9c760dd07cd1");
 451         UUID sequenceB2Uuid = UUID.fromString("1cb83575-38ea-4a8c-9418-d87163f425ce");
 452         UUID singleReadAUuid = UUID.fromString("82f538a1-2274-4d55-b27b-ed2f004ab5cd");
 453         UUID singleReadBUuid = UUID.fromString("fc74199a-89dc-40a0-9cbd-08cebebff4b5");
 454
 455         //how the XML was generated
 456         Sequence sequenceA1 = Sequence.NewInstance("A");
 457         Sequence sequenceA2 = Sequence.NewInstance("T");
 458         Sequence sequenceB1 = Sequence.NewInstance("C");
 459         Sequence sequenceB2 = Sequence.NewInstance("G");
 460
 461         SingleRead singleReadA = SingleRead.NewInstance();
 462         SingleRead singleReadB = SingleRead.NewInstance();
 463
 464         sequenceA1.setUuid(sequenceA1Uuid);
 465         sequenceA2.setUuid(sequenceA2Uuid);
 466         sequenceB1.setUuid(sequenceB1Uuid);
 467         sequenceB1.setUuid(sequenceB2Uuid);
 468         singleReadA.setUuid(singleReadAUuid);
 469         singleReadB.setUuid(singleReadBUuid);
 470
 471         SingleReadAlignment.NewInstance(sequenceA1, singleReadA);
 472         SingleReadAlignment.NewInstance(sequenceA2, singleReadA);
 473         SingleReadAlignment.NewInstance(sequenceB1, singleReadB);
 474         SingleReadAlignment.NewInstance(sequenceB2, singleReadB);
 475
 476         sequenceService.save(sequenceA1);
 477         sequenceService.save(sequenceA2);
 478         sequenceService.save(sequenceB1);
 479         sequenceService.save(sequenceB2);
 480
 481         commitAndStartNewTransaction(null);
 482
 483         setComplete();
 484         endTransaction();
 485
 486         try {
 487             writeDbUnitDataSetFile(new String[] {
 488                     "SpecimenOrObservationBase",
 489                     "SpecimenOrObservationBase_DerivationEvent",
 490                     "DerivationEvent",
 491                     "Sequence",
 492                     "SingleRead",
 493                     "SingleReadAlignment",
 494                     "Amplification",
 495                     "AmplificationResult",
 496                     "DescriptionElementBase",
 497                     "DescriptionBase",
 498                     "TaxonBase",
 499                     "TypeDesignationBase",
 500                     "TaxonName",
 501                     "TaxonName_TypeDesignationBase",
 502                     "HomotypicalGroup"
 503             }, "testDeepDelete_SingleRead", true);
 504         } catch (FileNotFoundException e) {
 505             e.printStackTrace();
 506         }
 507
 508         System.out.println(sequenceA1.getUuid());
 509         System.out.println(sequenceA2.getUuid());
 510         System.out.println(sequenceB1.getUuid());
 511         System.out.println(sequenceB2.getUuid());
 512         System.out.println(singleReadA.getUuid());
 513         System.out.println(singleReadB.getUuid());
 514     }
 515 }