cdmlib-io/src/test/java/eu/etaxonomy/cdm/io/specimen/abcd206/in/SpecimenImportConfiguratorTest.java

   1 /**
   2 * Copyright (C) 2007 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
  10 package eu.etaxonomy.cdm.io.specimen.abcd206.in;
  11
  12 import static org.junit.Assert.assertEquals;
  13 import static org.junit.Assert.assertNotNull;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import java.io.FileNotFoundException;
  17 import java.net.URISyntaxException;
  18 import java.net.URL;
  19 import java.text.ParseException;
  20 import java.util.List;
  21 import java.util.Set;
  22 import java.util.UUID;
  23
  24 import org.junit.Assert;
  25 import org.junit.Before;
  26 import org.junit.Ignore;
  27 import org.junit.Test;
  28 import org.unitils.dbunit.annotation.DataSet;
  29 import org.unitils.dbunit.annotation.DataSets;
  30 import org.unitils.spring.annotation.SpringBeanByName;
  31 import org.unitils.spring.annotation.SpringBeanByType;
  32
  33 import eu.etaxonomy.cdm.api.service.IAgentService;
  34 import eu.etaxonomy.cdm.api.service.IClassificationService;
  35 import eu.etaxonomy.cdm.api.service.ICommonService;
  36 import eu.etaxonomy.cdm.api.service.INameService;
  37 import eu.etaxonomy.cdm.api.service.IOccurrenceService;
  38 import eu.etaxonomy.cdm.api.service.IReferenceService;
  39 import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
  40 import eu.etaxonomy.cdm.api.service.ITaxonService;
  41 import eu.etaxonomy.cdm.api.service.ITermService;
  42 import eu.etaxonomy.cdm.io.common.CdmApplicationAwareDefaultImport;
  43 import eu.etaxonomy.cdm.io.common.IImportConfigurator;
  44 import eu.etaxonomy.cdm.model.agent.Institution;
  45 import eu.etaxonomy.cdm.model.agent.Person;
  46 import eu.etaxonomy.cdm.model.molecular.DnaSample;
  47 import eu.etaxonomy.cdm.model.name.Rank;
  48 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  49 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  50 import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
  51 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  52 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  53 import eu.etaxonomy.cdm.model.reference.Reference;
  54 import eu.etaxonomy.cdm.model.taxon.Classification;
  55 import eu.etaxonomy.cdm.model.taxon.Taxon;
  56 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  57 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  58 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  59 import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
  60 import eu.etaxonomy.cdm.test.unitils.CleanSweepInsertLoadStrategy;
  61
  62 /**
  63  * @author a.mueller
  64  * @created 29.01.2009
  65  */
  66 public class SpecimenImportConfiguratorTest extends CdmTransactionalIntegrationTest {
  67
  68         @SpringBeanByName
  69         private CdmApplicationAwareDefaultImport<?> defaultImport;
  70
  71         @SpringBeanByType
  72         private INameService nameService;
  73
  74         @SpringBeanByType
  75         private ITaxonService taxonService;
  76
  77         @SpringBeanByType
  78         private IOccurrenceService occurrenceService;
  79
  80         @SpringBeanByType
  81         private ITermService termService;
  82
  83         @SpringBeanByType
  84         private ICommonService commonService;
  85
  86         @SpringBeanByType
  87         private ITaxonNodeService taxonNodeService;
  88
  89         @SpringBeanByType
  90         private IAgentService agentService;
  91
  92         @SpringBeanByType
  93         private IReferenceService referenceService;
  94
  95         @SpringBeanByType
  96         private IClassificationService classificationService;
  97
  98
  99
 100         private IImportConfigurator configurator;
 101         private IImportConfigurator configurator2;
 102
 103         @Before
 104         public void setUp() {
 105                 String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/AbcdImportTestCalvumPart1.xml";
 106         URL url = this.getClass().getResource(inputFile);
 107         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 108         try {
 109             configurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 110         } catch (URISyntaxException e) {
 111             e.printStackTrace();
 112             Assert.fail();
 113         }
 114         assertNotNull("Configurator could not be created", configurator);
 115
 116         //test2
 117         String inputFile2 = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_ABCD_import_3_taxa_11_units.xml";
 118                 URL url2 = this.getClass().getResource(inputFile2);
 119                 assertNotNull("URL for the test file '" + inputFile2 + "' does not exist", url2);
 120                 try {
 121                         configurator2 = Abcd206ImportConfigurator.NewInstance(url2.toURI(), null,false);
 122                 } catch (URISyntaxException e) {
 123                         e.printStackTrace();
 124                         Assert.fail();
 125                 }
 126                 assertNotNull("Configurator2 could not be created", configurator2);
 127         }
 128
 129         @Test
 130         public void testInit() {
 131             System.out.println("TEST INIT");
 132                 assertNotNull("import instance should not be null", defaultImport);
 133                 assertNotNull("nameService should not be null", nameService);
 134                 assertNotNull("occurence service should not be null", occurrenceService);
 135                 assertNotNull("term service should not be null", termService);
 136                 assertNotNull("common service should not be null", commonService);
 137                 assertNotNull("taxon node service should not be null", taxonNodeService);
 138                 assertNotNull("agent service should not be null", agentService);
 139                 assertNotNull("reference service should not be null", referenceService);
 140         }
 141
 142         @Test
 143     @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 144     public void testDoInvoke() {
 145         boolean result = defaultImport.invoke(configurator).isSuccess();
 146         assertTrue("Return value for import.invoke should be true", result);
 147         assertEquals("Number of TaxonNames is incorrect", 2, nameService.count(TaxonNameBase.class));
 148         /*
 149          * Classification
 150          * - Cichorium
 151          *   - Cichorium calvum
 152          */
 153         assertEquals("Number of TaxonNodes is incorrect", 3, taxonNodeService.count(TaxonNode.class));
 154         assertEquals("Number of specimen and observation is incorrect", 10, occurrenceService.count(DerivedUnit.class));
 155         //Asch. + Mitarbeiter der Floristischen Kartierung Deutschlands
 156         assertEquals("Number of persons is incorrect", 2, agentService.count(Person.class));
 157         //BfN
 158         assertEquals("Number of institutions is incorrect", 1, agentService.count(Institution.class));
 159     }
 160
 161
 162         @Test
 163         @DataSet(value="SpecimenImportConfiguratorTest.doInvoke2.xml",  loadStrategy=CleanSweepInsertLoadStrategy.class)
 164         public void testDoInvoke2() {
 165                 boolean result = defaultImport.invoke(configurator2).isSuccess();
 166                 assertTrue("Return value for import.invoke should be true", result);
 167                 assertEquals("Number of TaxonNames is incorrect", 4, nameService.count(TaxonNameBase.class));
 168                 /*
 169                  * 5 taxon nodes:
 170                  *
 171          * Classification
 172          * - Campanula
 173          *   - Campanula patula
 174          *   - Campanula tridentata
 175          *   - Campanula lactiflora
 176          */
 177         assertEquals("Number of TaxonNodes is incorrect", 5, taxonNodeService.count(TaxonNode.class));
 178                 assertEquals("Number of derived units is incorrect", 11, occurrenceService.count(DerivedUnit.class));
 179                 assertEquals("Number of field units is incorrect", 11, occurrenceService.count(FieldUnit.class));
 180                 assertEquals("Number of gathering agents is incorrect", 4, agentService.count(Person.class));
 181                 //BGBM
 182                 assertEquals("Number of institutions is incorrect", 1, agentService.count(Institution.class));
 183                 assertEquals("Number of references is incorrect", 1, referenceService.count(Reference.class));
 184         }
 185
 186         @Test
 187     @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 188     public void testImportSubspecies() {
 189         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/camapanula_abietina_subspecies.xml";
 190         URL url = this.getClass().getResource(inputFile);
 191         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 192
 193         Abcd206ImportConfigurator importConfigurator = null;
 194         try {
 195             importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 196         } catch (URISyntaxException e) {
 197             e.printStackTrace();
 198             Assert.fail();
 199         }
 200         assertNotNull("Configurator could not be created", importConfigurator);
 201
 202         boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 203         assertTrue("Return value for import.invoke should be true", result);
 204         assertEquals("Number of TaxonNames is incorrect", 3, nameService.count(TaxonNameBase.class));
 205         /*
 206          * Classification
 207          * - Campanula
 208          *   - Campanula patula
 209          *      - Campanula patula subsp. abietina
 210          */
 211         assertEquals("Number of TaxonNodes is incorrect", 4, taxonNodeService.count(TaxonNode.class));
 212         }
 213
 214         @Test
 215         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 216         public void testImportVariety() {
 217             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_variety.xml";
 218             URL url = this.getClass().getResource(inputFile);
 219             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 220
 221             Abcd206ImportConfigurator importConfigurator = null;
 222             try {
 223                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 224             } catch (URISyntaxException e) {
 225                 e.printStackTrace();
 226                 Assert.fail();
 227             }
 228             assertNotNull("Configurator could not be created", importConfigurator);
 229
 230             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 231             assertTrue("Return value for import.invoke should be true", result);
 232
 233             /*
 234              * Classification
 235              *  - Campanula
 236              *   - Campanula versicolor
 237              *   - Campanula versicolor var. tomentella Hal.
 238              */
 239             assertEquals(4, taxonNodeService.count(TaxonNode.class));
 240             assertEquals(3, nameService.count(TaxonNameBase.class));
 241             assertEquals(1, occurrenceService.count(DerivedUnit.class));
 242             boolean varietyFound = false;
 243             for(TaxonNameBase<?, ?> name:nameService.list(TaxonNameBase.class, null, null, null, null)){
 244                 if(name.getRank().equals(Rank.VARIETY())){
 245                     varietyFound = true;
 246                 }
 247             }
 248             assertTrue("Variety rank not set", varietyFound);
 249         }
 250
 251         @Test
 252         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 253         public void testMultipleIdentificationsPreferredFlag() {
 254             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/MultipleIdentificationsPreferredFlag.xml";
 255             URL url = this.getClass().getResource(inputFile);
 256             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 257
 258             Abcd206ImportConfigurator importConfigurator = null;
 259             try {
 260                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 261             } catch (URISyntaxException e) {
 262                 e.printStackTrace();
 263                 Assert.fail();
 264             }
 265             assertNotNull("Configurator could not be created", importConfigurator);
 266
 267             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 268             assertTrue("Return value for import.invoke should be true", result);
 269
 270             String nonPreferredNameCache = "Campanula flagellaris";
 271             String preferredNameCache = "Campanula tymphaea";
 272             //Campanula, "Campanula tymphaea Hausskn.", "Campanula flagellaris Halácsy"
 273             assertEquals(3, nameService.count(TaxonNameBase.class));
 274             /*
 275              * Classification
 276              *  - Campanula
 277              *   - Campanula tymphaea Hausskn.
 278              */
 279             assertEquals(3, taxonNodeService.count(TaxonNode.class));
 280             assertEquals(1, occurrenceService.count(DerivedUnit.class));
 281             DerivedUnit derivedUnit = occurrenceService.list(DerivedUnit.class, null, null, null, null).get(0);
 282             assertEquals(2, derivedUnit.getDeterminations().size());
 283             for(DeterminationEvent determinationEvent:derivedUnit.getDeterminations()){
 284                 if(determinationEvent.getPreferredFlag()){
 285                     assertEquals(preferredNameCache,determinationEvent.getTaxonName().getNameCache());
 286                 }
 287                 else{
 288                     assertEquals(nonPreferredNameCache,determinationEvent.getTaxonName().getNameCache());
 289                 }
 290             }
 291
 292         }
 293
 294         @Test
 295     @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 296     public void testImportForm() {
 297         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/C_drabifolia_major.xml";
 298         URL url = this.getClass().getResource(inputFile);
 299         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 300
 301         Abcd206ImportConfigurator importConfigurator = null;
 302         try {
 303             importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 304         } catch (URISyntaxException e) {
 305             e.printStackTrace();
 306             Assert.fail();
 307         }
 308         assertNotNull("Configurator could not be created", importConfigurator);
 309
 310         boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 311         assertTrue("Return value for import.invoke should be true", result);
 312     }
 313
 314         @Test
 315         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 316         public void testMapUnitIDAsBarcode() {
 317             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_ABCD_import_3_taxa_11_units.xml";
 318             URL url = this.getClass().getResource(inputFile);
 319             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 320
 321             Abcd206ImportConfigurator importConfigurator = null;
 322             try {
 323                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 324             } catch (URISyntaxException e) {
 325                 e.printStackTrace();
 326                 Assert.fail();
 327             }
 328             assertNotNull("Configurator could not be created", importConfigurator);
 329
 330             importConfigurator.setMapUnitIdToBarcode(true);
 331             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 332             assertTrue("Return value for import.invoke should be true", result);
 333             List<DerivedUnit> list = occurrenceService.list(DerivedUnit.class, null, null, null, null);
 334             for (DerivedUnit derivedUnit : list) {
 335             assertTrue(derivedUnit.getBarcode()!=null);
 336         }
 337         }
 338
 339         @Test
 340         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 341         public void testMapUnitIDAsAccessionNumber() {
 342             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_ABCD_import_3_taxa_11_units.xml";
 343             URL url = this.getClass().getResource(inputFile);
 344             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 345
 346             Abcd206ImportConfigurator importConfigurator = null;
 347             try {
 348                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 349             } catch (URISyntaxException e) {
 350                 e.printStackTrace();
 351                 Assert.fail();
 352             }
 353             assertNotNull("Configurator could not be created", importConfigurator);
 354
 355             importConfigurator.setMapUnitIdToAccessionNumber(true);
 356             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 357             assertTrue("Return value for import.invoke should be true", result);
 358             List<DerivedUnit> list = occurrenceService.list(DerivedUnit.class, null, null, null, null);
 359             for (DerivedUnit derivedUnit : list) {
 360                 assertTrue(derivedUnit.getAccessionNumber()!=null);
 361             }
 362         }
 363
 364         @Test
 365         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 366         public void testMapUnitIDAsCatalogNumber() {
 367             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_ABCD_import_3_taxa_11_units.xml";
 368             URL url = this.getClass().getResource(inputFile);
 369             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 370
 371             Abcd206ImportConfigurator importConfigurator = null;
 372             try {
 373                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 374             } catch (URISyntaxException e) {
 375                 e.printStackTrace();
 376                 Assert.fail();
 377             }
 378             assertNotNull("Configurator could not be created", importConfigurator);
 379
 380             importConfigurator.setMapUnitIdToCatalogNumber(true);
 381             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 382             assertTrue("Return value for import.invoke should be true", result);
 383             List<DerivedUnit> list = occurrenceService.list(DerivedUnit.class, null, null, null, null);
 384             for (DerivedUnit derivedUnit : list) {
 385                 assertTrue(derivedUnit.getCatalogNumber()!=null);
 386             }
 387         }
 388
 389         @Test
 390     @DataSet( value="AbcdGgbnImportTest.testAttachDnaSampleToDerivedUnit.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 391     public void testIgnoreExistingSpecimens(){
 392         UUID derivedUnit1Uuid = UUID.fromString("eb40cb0f-efb2-4985-819e-a9168f6d61fe");
 393
 394 //        DerivedUnit derivedUnit = DerivedUnit.NewInstance(SpecimenOrObservationType.Fossil);
 395 //        derivedUnit.setAccessionNumber("B 10 0066577");
 396 //        derivedUnit.setTitleCache("testUnit1", true);
 397 //
 398 //        derivedUnit.setUuid(derivedUnit1Uuid );
 399 //
 400 //        occurrenceService.save(derivedUnit);
 401 //
 402 //        commitAndStartNewTransaction(null);
 403 //
 404 //        setComplete();
 405 //        endTransaction();
 406 //
 407 //
 408 //        try {
 409 //            writeDbUnitDataSetFile(new String[] {
 410 //                    "SpecimenOrObservationBase",
 411 //            }, "testAttachDnaSampleToDerivedUnit");
 412 //        } catch (FileNotFoundException e) {
 413 //            e.printStackTrace();
 414 //        }
 415
 416
 417         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_B_10_0066577.xml";
 418         URL url = this.getClass().getResource(inputFile);
 419         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 420
 421         Abcd206ImportConfigurator importConfigurator = null;
 422         try {
 423             importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 424         } catch (URISyntaxException e) {
 425             e.printStackTrace();
 426             Assert.fail();
 427         }
 428         assertNotNull("Configurator could not be created", importConfigurator);
 429         importConfigurator.setIgnoreImportOfExistingSpecimen(true);
 430         boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 431         assertTrue("Return value for import.invoke should be true", result);
 432         assertEquals("Number of derived units is incorrect", 1, occurrenceService.count(DerivedUnit.class));
 433         List<DerivedUnit> derivedUnits = occurrenceService.list(DerivedUnit.class, null, null, null, null);
 434         assertEquals("Number of derived units is incorrect", 1, derivedUnits.size());
 435
 436         DerivedUnit derivedUnit = (DerivedUnit) occurrenceService.load(derivedUnit1Uuid);
 437         assertTrue(derivedUnits.contains(derivedUnit));
 438
 439     }
 440
 441         /**
 442          * Test imports one unit with an already existing taxon and one with a new taxon.
 443          * The new taxon should be added to a newly created default classification.
 444          */
 445         @Test
 446     @DataSets({
 447         @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/BlankDataSet.xml"),
 448         @DataSet( value="SpecimenImportConfiguratorTest.testIgnoreAuthorship.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 449     })
 450         public void testImportNewTaxaToDefaultClassification(){
 451             UUID taxonUUID = UUID.fromString("26f98a58-09ab-49a0-ab9f-7490757c86d2");
 452             UUID classificationUUID = UUID.fromString("eee32748-5b89-4266-a99a-1edb3781d0eb");
 453
 454             String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_B_10_0066577_two_units_almost_same.xml";
 455             URL url = this.getClass().getResource(inputFile);
 456             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 457
 458             Abcd206ImportConfigurator importConfigurator = null;
 459             try {
 460                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 461             } catch (URISyntaxException e) {
 462                 e.printStackTrace();
 463                 Assert.fail();
 464             }
 465             assertNotNull("Configurator could not be created", importConfigurator);
 466
 467             //test initial state
 468             Taxon taxon = (Taxon) taxonService.load(taxonUUID);
 469             assertNotNull(taxon);
 470             Classification classification = classificationService.load(classificationUUID);
 471             assertNotNull(classification);
 472             assertEquals(1, taxon.getTaxonNodes().size());
 473             TaxonNode taxonNode = taxon.getTaxonNodes().iterator().next();
 474             assertEquals(classification, taxonNode.getClassification());
 475
 476             assertEquals(1, classificationService.count(Classification.class));
 477             assertEquals(1, taxonService.count(Taxon.class));
 478
 479             importConfigurator.setClassificationUuid(classificationUUID);
 480 //          importConfigurator.setIgnoreAuthorship(true);
 481             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 482             assertTrue("Return value for import.invoke should be true", result);
 483
 484             //re-load classification to avoid session conflicts
 485             classification = classificationService.load(classificationUUID);
 486
 487             assertEquals(2, occurrenceService.count(DerivedUnit.class));
 488 //          assertEquals(2, taxonService.count(Taxon.class));
 489             assertEquals(2, classificationService.count(Classification.class));
 490
 491             //get default classification
 492             List<Classification> list = classificationService.list(Classification.class, null, null, null, null);
 493             Classification defaultClassification = null;
 494             for (Classification c : list) {
 495             if(c.getUuid()!=classificationUUID){
 496                 defaultClassification = c;
 497             }
 498         }
 499             assertEquals(1, classification.getAllNodes().size());
 500             assertEquals(2, defaultClassification.getAllNodes().size());
 501
 502         }
 503
 504
 505     /**
 506      * Test should NOT create new taxa of the same name but have different authors.
 507      */
 508         @Test
 509     @DataSets({
 510         @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/BlankDataSet.xml"),
 511         @DataSet( value="SpecimenImportConfiguratorTest.testIgnoreAuthorship.xml")
 512     })
 513         public void testIgnoreAuthorship(){
 514         UUID taxonUUID = UUID.fromString("26f98a58-09ab-49a0-ab9f-7490757c86d2");
 515         UUID classificationUUID = UUID.fromString("eee32748-5b89-4266-a99a-1edb3781d0eb");
 516
 517 //        Classification classification = Classification.NewInstance("Checklist");
 518 //        classification.setUuid(classificationUUID);
 519 //
 520 //        Reference<?> secReference = ReferenceFactory.newGeneric();
 521 //        Team team = Team.NewTitledInstance("different author", "different author");
 522 //        secReference.setAuthorship(team);
 523 //
 524 //        INonViralName taxonName = TaxonNameFactory.NewNonViralInstance(Rank.VARIETY());
 525 //        taxonName.setGenusOrUninomial("Campanula");
 526 //        taxonName.setSpecificEpithet("versicolor");
 527 //        taxonName.setInfraSpecificEpithet("tomentella");
 528 //
 529 //        Taxon taxon = Taxon.NewInstance(taxonName, secReference);
 530 //        taxon.setUuid(taxonUUID);
 531 //
 532 //        classification.addChildTaxon(taxon, secReference, "");
 533 //
 534 //        taxonService.save(taxon);
 535 //        nameService.save(taxonName);
 536 //        referenceService.save(secReference);
 537 //
 538 //        commitAndStartNewTransaction(null);
 539 //
 540 //        setComplete();
 541 //        endTransaction();
 542 //
 543 //
 544 //        try {
 545 //            writeDbUnitDataSetFile(new String[] {
 546 //                    "SpecimenOrObservationBase",
 547 //                    "SpecimenOrObservationBase_DerivationEvent",
 548 //                    "DerivationEvent",
 549 //                    "DescriptionElementBase",
 550 //                    "DescriptionBase",
 551 //                    "TaxonBase",
 552 //                    "TypeDesignationBase",
 553 //                    "TaxonNameBase",
 554 //                    "TaxonNameBase_TypeDesignationBase",
 555 //                    "HomotypicalGroup",
 556 //                    "AgentBase",
 557 //                    "AgentBase_AgentBase",
 558 //                    "Reference",
 559 //                    "TaxonNode",
 560 //                    "Classification",
 561 //                    "LanguageString"
 562 //            }, "testIgnoreAuthorship");
 563 //        } catch (FileNotFoundException e) {
 564 //            e.printStackTrace();
 565 //        }
 566
 567         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_B_10_0066577.xml";
 568             URL url = this.getClass().getResource(inputFile);
 569             assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 570
 571             Abcd206ImportConfigurator importConfigurator = null;
 572             try {
 573                 importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 574             } catch (URISyntaxException e) {
 575                 e.printStackTrace();
 576                 Assert.fail();
 577             }
 578             assertNotNull("Configurator could not be created", importConfigurator);
 579
 580             //test initial state
 581             Taxon taxon = (Taxon) taxonService.load(taxonUUID);
 582             assertNotNull(taxon);
 583             Classification classification = classificationService.load(classificationUUID);
 584             assertNotNull(classification);
 585             assertEquals(1, classificationService.count(Classification.class));
 586             assertEquals(1, classification.getAllNodes().size());//taxon node
 587             assertEquals(2, taxonNodeService.count(TaxonNode.class));//root node + Taxon node = 2 nodes
 588
 589             importConfigurator.setIgnoreAuthorship(true);
 590             importConfigurator.setClassificationUuid(classificationUUID);
 591             boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 592             assertTrue("Return value for import.invoke should be true", result);
 593
 594             assertEquals(1, classificationService.count(Classification.class));
 595             assertEquals(1, classification.getAllNodes().size());//taxon node
 596             assertEquals(2, taxonNodeService.count(TaxonNode.class));//root node + Taxon node = 2 nodes
 597
 598         }
 599
 600     /**
 601      * Imports two DNA units belonging to the same taxon into an existing
 602      * classification. The taxon is not part of the classification so the
 603      * default classification will be created. The result should be:
 604      * existing classification (0 taxa), default classification (2 taxa [genus+species])
 605      */
 606     @Test
 607     @DataSets({
 608         @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/ClearDB_with_Terms_DataSet.xml"),
 609         @DataSet("/eu/etaxonomy/cdm/database/TermsDataSet-with_auditing_info.xml"),
 610         @DataSet( value="SpecimenImportConfiguratorTest.testImportTwoUnitsOfSameTaxonIntoExistingClassification.xml")
 611     })
 612         public void testImportTwoUnitsOfSameTaxonIntoExistingClassification(){
 613         UUID classificationUUID = UUID.fromString("18d22d00-5f70-4c8e-a1ed-dc45fae5b816");
 614
 615         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_barbata.xml";
 616         URL url = this.getClass().getResource(inputFile);
 617         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 618
 619         Abcd206ImportConfigurator importConfigurator = null;
 620         try {
 621             importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 622         } catch (URISyntaxException e) {
 623             e.printStackTrace();
 624             Assert.fail();
 625         }
 626         assertNotNull("Configurator could not be created", importConfigurator);
 627
 628         //test initial state
 629         Classification classification = classificationService.load(classificationUUID);
 630         assertNotNull(classification);
 631         assertEquals(0, classification.getAllNodes().size());
 632         assertEquals(1, classificationService.count(Classification.class));
 633
 634
 635         importConfigurator.setIgnoreAuthorship(true);
 636         importConfigurator.setClassificationUuid(classificationUUID);
 637         boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 638         assertTrue("Return value for import.invoke should be true", result);
 639
 640         assertEquals(0, classification.getAllNodes().size());
 641         assertEquals(2, classificationService.count(Classification.class));
 642
 643         Classification defaultClassification = null;
 644         for (Classification c : classificationService.list(Classification.class, null, null, null, null)) {
 645             if(!c.getUuid().equals(classificationUUID)){
 646                 defaultClassification = c;
 647             }
 648         }
 649         assertNotNull(defaultClassification);
 650         Set<TaxonNode> allNodes = defaultClassification.getAllNodes();
 651         for (TaxonNode node:allNodes){
 652             System.out.println(node.getTaxon().getTitleCache());
 653         }
 654
 655         assertEquals(3, defaultClassification.getAllNodes().size());
 656
 657         }
 658
 659     /**
 660      * Tests import of unit belonging to a taxon with a non-parsable name. Since
 661      * no rank can be deduced from the name there will be no taxon hierarchy
 662      * created but only the single taxon
 663      *
 664      * @throws ParseException
 665      */
 666     @Test
 667     @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 668     public void testImportNonParsableName() {
 669         String inputFile = "/eu/etaxonomy/cdm/io/specimen/abcd206/in/Campanula_americana.xml";
 670         URL url = this.getClass().getResource(inputFile);
 671         assertNotNull("URL for the test file '" + inputFile + "' does not exist", url);
 672
 673         Abcd206ImportConfigurator importConfigurator = null;
 674         try {
 675             importConfigurator = Abcd206ImportConfigurator.NewInstance(url.toURI(), null,false);
 676         } catch (URISyntaxException e) {
 677             e.printStackTrace();
 678             Assert.fail();
 679         }
 680         assertNotNull("Configurator could not be created", importConfigurator);
 681
 682         boolean result = defaultImport.invoke(importConfigurator).isSuccess();
 683         assertTrue("Return value for import.invoke should be true", result);
 684         assertEquals("Number of derived units is incorrect", 1, occurrenceService.count(DerivedUnit.class));
 685         assertEquals("Number of dna samples is incorrect", 1, occurrenceService.count(DnaSample.class));
 686         assertEquals("Number of field units is incorrect", 1, occurrenceService.count(FieldUnit.class));
 687         taxonNodeService.list(TaxonNode.class, null, null, null, null);
 688         occurrenceService.list(SpecimenOrObservationBase.class, null, null, null, null);
 689         /*
 690          * Default classification
 691          *   - Campanula ..g... americana --- hort. ttt ex Steud.
 692          */
 693         assertEquals("Number of taxon nodes is incorrect", 2, taxonNodeService.count(TaxonNode.class));
 694         assertEquals("Number of taxa is incorrect", 1, taxonService.count(TaxonBase.class));
 695         assertEquals(1, taxonService.findByTitle(Taxon.class, "Campanula ..g... americana --- hort. ttt ex Steud.", MatchMode.ANYWHERE, null, null, null, null, null).getRecords().size());
 696     }
 697
 698         @Test
 699         @Ignore
 700         @DataSet( value="/eu/etaxonomy/cdm/database/BlankDataSet.xml", loadStrategy=CleanSweepInsertLoadStrategy.class)
 701         public void testSetUnitIDAsBarcode() {
 702
 703         }
 704
 705     @Override
 706 //    @Test
 707     public void createTestDataSet() throws FileNotFoundException {
 708         UUID classificationUUID = UUID.fromString("18d22d00-5f70-4c8e-a1ed-dc45fae5b816");
 709
 710         Classification classification = Classification.NewInstance("Checklist");
 711         classification.setUuid(classificationUUID);
 712
 713         classificationService.save(classification);
 714
 715         commitAndStartNewTransaction(null);
 716
 717         setComplete();
 718         endTransaction();
 719
 720
 721         try {
 722             writeDbUnitDataSetFile(new String[] {
 723                     "SpecimenOrObservationBase",
 724                     "SpecimenOrObservationBase_DerivationEvent",
 725                     "DerivationEvent",
 726                     "DescriptionElementBase",
 727                     "DescriptionBase",
 728                     "TaxonBase",
 729                     "TypeDesignationBase",
 730                     "TaxonNameBase",
 731                     "TaxonNameBase_TypeDesignationBase",
 732                     "HomotypicalGroup",
 733                     "AgentBase",
 734                     "AgentBase_AgentBase",
 735                     "Reference",
 736                     "TaxonNode",
 737                     "Classification",
 738                     "LanguageString"
 739             }, "testImportTwoUnitsOfSameTaxonIntoExistingClassification");
 740         } catch (FileNotFoundException e) {
 741             e.printStackTrace();
 742         }
 743     }
 744 }