import org.unitils.dbunit.annotation.DataSet;
import org.unitils.spring.annotation.SpringBeanByType;
+import eu.etaxonomy.cdm.api.service.config.IdentifiableServiceConfiguratorImpl;
import eu.etaxonomy.cdm.api.service.config.IncludedTaxonConfiguration;
+import eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator;
import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;
import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.dto.IncludedTaxaDTO;
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
+import eu.etaxonomy.cdm.api.service.pager.Pager;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.common.Annotation;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.LanguageString;
import eu.etaxonomy.cdm.model.common.Marker;
import eu.etaxonomy.cdm.model.common.MarkerType;
-import eu.etaxonomy.cdm.model.common.OriginalSourceType;
import eu.etaxonomy.cdm.model.description.CommonTaxonName;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
+import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.Rank;
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;
+import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
+import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
+import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
+import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
+import eu.etaxonomy.cdm.model.reference.OriginalSourceType;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.model.taxon.Classification;
/**
* @author a.mueller
*/
-
-
public class TaxonServiceImplTest extends CdmTransactionalIntegrationTest {
private static final Logger logger = Logger.getLogger(TaxonServiceImplTest.class);
assertEquals(expectedTaxon, actualTaxon);
}
+ /**
+ * Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#getTaxonByUuid(java.util.UUID)}.
+ */
+ @Test
+ public final void testGetTaxonByTitle() {
+ TaxonName name = TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SPECIES(), "Abies", null, "alba", null, null, null, null, null);
+ Taxon expectedTaxon = Taxon.NewInstance(name, null);
+ expectedTaxon.setDoubtful(true);
+ TaxonBase taxon = service.save(expectedTaxon);
+ IdentifiableServiceConfiguratorImpl<TaxonBase> config = new IdentifiableServiceConfiguratorImpl<TaxonBase>();
+ config.setTitleSearchString("Abies alba*");
+ //doubtful taxa should be found
+ Pager<TaxonBase> actualTaxa = service.findByTitle(config);
+ assertEquals(expectedTaxon, actualTaxa.getRecords().get(0));
+
+ //and other taxa as well
+ expectedTaxon.setDoubtful(false);
+ service.saveOrUpdate(expectedTaxon);
+ actualTaxa = service.findByTitle(config);
+ assertEquals(expectedTaxon, actualTaxa.getRecords().get(0));
+ }
+
+
/**
* Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#saveTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.
*/
Assert.fail();
}
}
+
+ @Test
+ public final void testSaveOrUpdateTaxonWithMisappliedName() {
+ Taxon expectedTaxon = Taxon.NewInstance(null, null);
+ TaxonName misappliedNameName = TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SPECIES(), "Abies", null, "alba", null, null, null, null, null);
+
+ UUID misappliedNameNameUuid = nameService.save(misappliedNameName).getUuid();
+ misappliedNameName = nameService.find(misappliedNameNameUuid);
+ SpecimenTypeDesignation typedes = SpecimenTypeDesignation.NewInstance();
+ DerivedUnit derivedUnit = DerivedUnit.NewPreservedSpecimenInstance();
+ FieldUnit fieldUnit = FieldUnit.NewInstance();
+ DerivationEvent derivationEvent = DerivationEvent.NewSimpleInstance(fieldUnit, derivedUnit, DerivationEventType.ACCESSIONING());
+// derivedUnit.addDerivationEvent(derivationEvent);
+ typedes.setTypeSpecimen(derivedUnit);
+ misappliedNameName.addTypeDesignation(typedes, false);
+ Taxon misappliedName = Taxon.NewInstance(misappliedNameName, null);
+ UUID misappliedNameUuid = service.save(misappliedName).getUuid();
+ misappliedName = (Taxon) service.find(misappliedNameUuid);
+ expectedTaxon.addMisappliedName(misappliedName, null, null);
+ UUID uuid = service.save(expectedTaxon).getUuid();
+ TaxonBase<?> actualTaxon = service.find(uuid);
+ assertEquals(expectedTaxon, actualTaxon);
+ misappliedName.setSec(ReferenceFactory.newArticle());
+
+ try{
+ service.saveOrUpdate(actualTaxon);
+ misappliedName = (Taxon)service.find(misappliedNameUuid);
+ Assert.assertNotNull(misappliedName.getSec());
+ }catch(Exception e){
+ Assert.fail();
+ }
+ commitAndStartNewTransaction(null);
+ actualTaxon = service.find(uuid);
+ ((Taxon)actualTaxon).getTaxonRelations(misappliedName).iterator().next().getFromTaxon().setSec(null);
+ try{
+ service.saveOrUpdate(actualTaxon);
+ misappliedName = (Taxon)service.find(misappliedNameUuid);
+ Assert.assertNull(misappliedName.getSec());
+ }catch(Exception e){
+ Assert.fail();
+ }
+ }
+
/**
* Test method for {@link eu.etaxonomy.cdm.api.service.TaxonServiceImpl#removeTaxon(eu.etaxonomy.cdm.model.taxon.TaxonBase)}.
*/
e.printStackTrace();
}
- service.swapSynonymAndAcceptedTaxon(synonym, taxWithSyn);
+ UpdateResult result = service.swapSynonymAndAcceptedTaxon(synonym, taxWithSyn, true);
// find forces flush
- Taxon tax = (Taxon)service.find(uuidTaxWithSyn);
- tax.removeSynonym(synonym);
- tax.addHomotypicSynonym(synonym);
- service.saveOrUpdate(tax);
- TaxonBase<?> syn = service.find(uuidSyn);
+ Taxon tax = (Taxon)service.find(result.getCdmEntity().getUuid());
+ MatchingTaxonConfigurator configurator = MatchingTaxonConfigurator.NewInstance();
+ configurator.setTaxonNameTitle("Test3");
+ List<TaxonBase> synList = service.findTaxaByName(configurator);
+ HomotypicalGroup groupTest2 = null;
+ if (synList.size() > 0){
+ TaxonBase syn = synList.get(0);
+ groupTest2 = syn.getHomotypicGroup();
+ assertTrue(tax.getSynonyms().contains(syn));
+ }else{
+ Assert.fail("There should be a synonym with name Test3");
+ }
assertTrue(tax.getName().getTitleCache().equals("Test2"));
- HomotypicalGroup groupTest = tax.getHomotypicGroup();
- HomotypicalGroup groupTest2 = syn.getHomotypicGroup();
- assertEquals(groupTest, groupTest2);
+
}
oldTaxon = heterotypicSynonym.getAcceptedTaxon();
Assert.assertEquals("Detail should be ref1", ref1, heterotypicSynonym.getSec());
Assert.assertEquals("Detail should be 'rel3'", "rel3", heterotypicSynonym.getSecMicroReference());
- TaxonNameBase<?,?> oldSynName3 = heterotypicSynonym.getName();
+ TaxonName oldSynName3 = heterotypicSynonym.getName();
Synonym heterotypicSynonym4 = (Synonym)service.load(uuidSyn4);
Assert.assertNotNull("Synonym should exist", heterotypicSynonym4);
Assert.assertNotNull("Synonym should still exist", heterotypicSynonym);
Assert.assertNotNull("Synonym should still have accepted taxon", heterotypicSynonym.getAcceptedTaxon());
Assert.assertEquals("Accepted taxon of relation should be new taxon now", newTaxon, heterotypicSynonym.getAcceptedTaxon());
- TaxonNameBase<?,?> synName3 = heterotypicSynonym.getName();
+ TaxonName synName3 = heterotypicSynonym.getName();
heterotypicSynonym = (Synonym)service.load(uuidSyn4);
Assert.assertNotNull("Synonym should still exist", heterotypicSynonym);
Assert.assertEquals("Accepted taxon of relation should be new taxon now", newTaxon, heterotypicSynonym.getAcceptedTaxon());
Assert.assertNull("Old citation should be removed", heterotypicSynonym.getSec());
Assert.assertNull("Old detail should be removed", heterotypicSynonym.getSecMicroReference());
- TaxonNameBase<?,?> synName4 = heterotypicSynonym.getName();
+ TaxonName synName4 = heterotypicSynonym.getName();
Assert.assertEquals("Homotypic group of both synonyms should be equal", synName3.getHomotypicalGroup() , synName4.getHomotypicalGroup() );
Assert.assertSame("Homotypic group of both synonyms should be same", synName3.getHomotypicalGroup() , synName4.getHomotypicalGroup() );
Assert.assertEquals("Homotypic group of both synonyms should be equal to old homotypic group", oldSynName3.getHomotypicalGroup() , synName3.getHomotypicalGroup() );
//test delete synonym, but the name will not be deleted
public final void testDeleteSynonymSynonymTaxonDontDeleteName(){
final String[]tableNames = {
-// "TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+// "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
// "HomotypicalGroup","HomotypicalGroup_AUD"
};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be two relationship left in the database", 2, nRelations);
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names left in the database", 4, nNames);
nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be no relationship left in the database", 1, nRelations);
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")
//test delete synonym and his name
public final void testDeleteSynonymSynonymTaxonDeleteName(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be 2 relationship left in the database", 2, nRelations);
UUID uuidSynonym1=UUID.fromString("7da85381-ad9d-4886-9d4d-0eeef40e3d88");
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 3 names left in the database", 3, nNames);
nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be 1 relationship left in the database", 1, nRelations);
//test remove synonym from taxon -> synonym and name still in the db and the synonymrelationship to the other taxon
//test delete synonym -> all relationships are deleted, the name is deleted and the synonym itself
public final void testDeleteSynonymSynonymTaxonBooleanRelToOneTaxon(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
List<String> initStrat = new ArrayList<String>();
initStrat.add("markers");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1, initStrat);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be 2 relationship left in the database", 2, nRelations);
taxon2.removeSynonym(synonym1, false);
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be 1 relationship left in the database", 1, nRelations);
commitAndStartNewTransaction(tableNames);
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 1 synonym left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 3 names left in the database", 3, nNames);
nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be no relationship left in the database", 1, nRelations);
//test delete synonym, only for a special taxon, but because of other relationships it will not be deleted at all
public final void testDeleteSynonymSynonymTaxonBooleanDeleteOneTaxon(){
final String[]tableNames = {
-// "TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+// "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
// "HomotypicalGroup","HomotypicalGroup_AUD"
};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
UUID uuidTaxon2=UUID.fromString("2d9a642d-5a82-442d-8fec-95efa978e8f8");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
taxon2.addSynonym(synonym1, SynonymType.HETEROTYPIC_SYNONYM_OF());
service.saveOrUpdate(synonym1);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
//this was "3" when we still had synonym relationships
Assert.assertEquals("There should be 2 relationship left in the database", 2, nRelations);
service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());
nSynonyms = service.count(Synonym.class);
//this was "2" when we still had synonym relationships
Assert.assertEquals("There should still be 1 synonym left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
//was 3
Assert.assertEquals("There should be 3 names left in the database", 3, nNames);
nRelations = service.countSynonyms(true);
public final void testDeleteSynonymWithAnnotations(){
final String[]tableNames = {
-// "TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+// "TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
// "HomotypicalGroup","HomotypicalGroup_AUD"
};
@DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedName(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
- TaxonNameBase<?,?> name2 = nameService.load(uuidSynonymName2);
+ TaxonName name2 = nameService.load(uuidSynonymName2);
UUID name3Uuid = synonym1.getName().getUuid();
- TaxonNameBase<?,?> name3 = nameService.load(name3Uuid);
- name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);
+ TaxonName name3 = nameService.load(name3Uuid);
+ name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null, null);
service.saveOrUpdate(synonym1);
- int nRelations = nameService.getAllRelationships(1000, 0).size();
+ long nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);
SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();
//synonym is deleted, but the name can not be deleted because of a name relationship
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names left in the database (name is related to synonymName2)", 4, nNames);
nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
- nRelations = nameService.getAllRelationships(1000, 0).size();
+ nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);
@Test
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")
public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameDeleteAllNameRelations(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
- TaxonNameBase<?,?> name2 = nameService.load(uuidSynonymName2);
+ TaxonName name2 = nameService.load(uuidSynonymName2);
UUID name3Uuid = synonym1.getName().getUuid();
- TaxonNameBase<?,?> name3 = nameService.load(name3Uuid);
- name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);
+ TaxonName name3 = nameService.load(name3Uuid);
+ name3.addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null, null);
service.saveOrUpdate(synonym1);
- int nRelations = nameService.getAllRelationships(1000, 0).size();
+ long nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);
SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 3 names left in the database ", 3, nNames);
nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
- nRelations = nameService.getAllRelationships(1000, 0).size();
+ nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be no name relationship left in the database", 0, nRelations);
}
@Test
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="TaxonServiceImplTest.testDeleteSynonym.xml")
public final void testDeleteSynonymSynonymTaxonBooleanWithRelatedNameIgnoreIsBasionym(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
UUID uuidTaxon1=UUID.fromString("c47fdb72-f32c-452e-8305-4b44f01179d0");
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
- TaxonNameBase<?,?> synName2 = nameService.load(uuidSynonymName2);
+ TaxonName synName2 = nameService.load(uuidSynonymName2);
UUID name3Uuid = synonym1.getName().getUuid();
- TaxonNameBase<?,?> synName1 = nameService.load(name3Uuid);
- synName1.addRelationshipFromName(synName2, NameRelationshipType.BASIONYM(), null);
+ TaxonName synName1 = nameService.load(name3Uuid);
+ synName1.addRelationshipFromName(synName2, NameRelationshipType.BASIONYM(), null, null);
service.saveOrUpdate(synonym1);
- int nRelations = nameService.getAllRelationships(1000, 0).size();
+ long nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be 1 name relationship left in the database", 1, nRelations);
SynonymDeletionConfigurator config = new SynonymDeletionConfigurator();
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should still be 1 synonyms left in the database", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 3 names left in the database ", 3, nNames);
nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
- nRelations = nameService.getAllRelationships(1000, 0).size();
+ nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
logger.info("number of name relations: " + nRelations);
Assert.assertEquals("There should be no name relationship left in the database", 0, nRelations);
}
@Test
@DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
public final void testDeleteSynonymSynonymTaxonBooleanWithRollback(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
- TaxonNameBase<?,?> name2 = nameService.load(uuidSynonymName2);
- synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);
+ TaxonName name2 = nameService.load(uuidSynonymName2);
+ synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null, null);
service.deleteSynonym(synonym1, new SynonymDeletionConfigurator());
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should still be 2 synonyms left in the database", 2, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names left in the database", 4, nNames);
nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
@Test
@DataSet("TaxonServiceImplTest.testDeleteSynonym.xml")
public final void testDeleteSynonymSynonymTaxonBooleanWithoutTransaction(){
- final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonNameBase","TaxonNameBase_AUD",
+ @SuppressWarnings("unused")
+ final String[]tableNames = {"TaxonBase","TaxonBase_AUD", "TaxonName","TaxonName_AUD",
"HomotypicalGroup","HomotypicalGroup_AUD"};
int nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should be 2 synonyms in the database", 2, nSynonyms);
- int nNames = nameService.count(TaxonNameBase.class);
+ int nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names in the database", 4, nNames);
- int nRelations = service.countSynonyms(true);
+ long nRelations = service.countSynonyms(true);
//may change with better implementation of countAllRelationships (see #2653)
Assert.assertEquals("There should be 2 relationship in the database (the 2 synonym relationships) but no name relationship", 2, nRelations);
UUID uuidSynonymName2=UUID.fromString("613f3c93-013e-4ffc-aadc-1c98d71c335e");
Synonym synonym1 = (Synonym)service.load(uuidSynonym1);
- TaxonNameBase<?,?> name2 = nameService.load(uuidSynonymName2);
- synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null);
+ TaxonName name2 = nameService.load(uuidSynonymName2);
+ synonym1.getName().addRelationshipFromName(name2, NameRelationshipType.LATER_HOMONYM(), null, null);
service.saveOrUpdate(synonym1);
nRelations = service.countSynonyms(true);
nSynonyms = service.count(Synonym.class);
Assert.assertEquals("There should still be 1 synonyms left in the database. The rollback on name delete should not lead to rollback in synonym delete.", 1, nSynonyms);
- nNames = nameService.count(TaxonNameBase.class);
+ nNames = nameService.count(TaxonName.class);
Assert.assertEquals("There should be 4 names left in the database", 4, nNames);
nRelations = service.countSynonyms(true);
Assert.assertEquals("There should be no taxon or synonym relationship in the database", 1, nRelations);
- nRelations = nameService.getAllRelationships(1000,0).size();
+ nRelations = nameService.listNameRelationships(null, 1000, 0, null, null).size();
Assert.assertEquals("There should be one name relationship in the database", 1, nRelations);
}
}
@Test
- @DataSet("BlankDataSet.xml")
+ @DataSet("../../database/ClearDBDataSet.xml")
public final void testTaxonDeletionConfig(){
- final String[]tableNames = {
- "Classification", "Classification_AUD",
- "TaxonBase","TaxonBase_AUD",
- "TaxonNode","TaxonNode_AUD",
- "TaxonNameBase","TaxonNameBase_AUD",
- "TaxonRelationship", "TaxonRelationship_AUD",
- "TaxonDescription", "TaxonDescription_AUD",
- "HomotypicalGroup","HomotypicalGroup_AUD",
- "PolytomousKey","PolytomousKey_AUD",
- "PolytomousKeyNode","PolytomousKeyNode_AUD",
- "Media","Media_AUD",
- "WorkingSet","WorkingSet_AUD",
- "DescriptionElementBase","DescriptionElementBase_AUD",
- "DeterminationEvent","DeterminationEvent_AUD",
- "SpecimenOrObservationBase","SpecimenOrObservationBase_AUD"};
+ final String[]tableNames = {}
+// "Classification", "Classification_AUD",
+// "TaxonBase","TaxonBase_AUD",
+// "TaxonNode","TaxonNode_AUD",
+// "TaxonName","TaxonName_AUD",
+// "TaxonRelationship", "TaxonRelationship_AUD",
+// "TaxonDescription", "TaxonDescription_AUD",
+// "HomotypicalGroup","HomotypicalGroup_AUD",
+// "PolytomousKey","PolytomousKey_AUD",
+// "PolytomousKeyNode","PolytomousKeyNode_AUD",
+// "Media","Media_AUD",
+// "DescriptiveDataSet","DescriptiveDataSet_AUD",
+// "DescriptionElementBase","DescriptionElementBase_AUD",
+// "DeterminationEvent","DeterminationEvent_AUD",
+// "SpecimenOrObservationBase","SpecimenOrObservationBase_AUD"}
+ ;
UUID uuidParent=UUID.fromString("b5271d4f-e203-4577-941f-00d76fa9f4ca");
UUID uuidChild1=UUID.fromString("326167f9-0b97-4e7d-b1bf-4ca47b82e21e");
Assert.assertNotNull("Child taxon should exist", child1);
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();
config.setDeleteTaxonNodes(false);
- config.setDeleteMisappliedNamesAndInvalidDesignations(false);
+ config.setDeleteMisappliedNames(false);
//try {
//commitAndStartNewTransaction(tableNames);
nTaxa = service.count(Taxon.class);
Assert.assertEquals("There should be 2 taxa in the database",2, nTaxa);
-// nNames = nameService.count(TaxonNameBase.class);
+// nNames = nameService.count(TaxonName.class);
// Assert.assertEquals("There should be 3 names left in the database", 3, nNames);
// int nRelations = service.countAllRelationships();
// Assert.assertEquals("There should be no relationship left in the database", 0, nRelations);
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxon(){
//create a small classification
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonWithAnnotations(){
//create a small classification
descrUUID = descr.getUuid();
descrElementUUID = descr.getElements().iterator().next().getUuid();
}
- BotanicalName taxonName = (BotanicalName) nameService.find(SPECIES1_NAME_UUID);
+ IBotanicalName taxonName = nameService.find(SPECIES1_NAME_UUID);
assertNotNull(taxonName);
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();
}
commitAndStartNewTransaction(null);
- taxonName = (BotanicalName) nameService.find(SPECIES1_NAME_UUID);
+ taxonName = nameService.find(SPECIES1_NAME_UUID);
Taxon taxon = (Taxon)service.find(SPECIES1_UUID);
//descriptionService.find(descrUUID);
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonUsedInTaxonRelation(){
//create a small classification
}
@Test
- @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="BlankDataSet.xml")
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonDeleteSynonymRelations(){
final String[]tableNames = {
"Classification", "Classification_AUD",
"TaxonBase","TaxonBase_AUD",
"TaxonNode","TaxonNode_AUD",
- "TaxonNameBase","TaxonNameBase_AUD"};
+ "TaxonName","TaxonName_AUD"};
commitAndStartNewTransaction(tableNames);
//create a small classification
Taxon testTaxon = getTestTaxon();
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonNameUsedInOtherContext(){
//create a small classification
IBotanicalName taxonName = nameService.find(SPECIES1_NAME_UUID);
assertNotNull(taxonName);
- TaxonNameBase fromName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
- taxonName.addRelationshipFromName(fromName, NameRelationshipType.VALIDATED_BY_NAME(), null);
+ TaxonName fromName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ taxonName.addRelationshipFromName(fromName, NameRelationshipType.VALIDATED_BY_NAME(), null, null);
+ nameService.save(fromName);
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();
config.setDeleteNameIfPossible(true);
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonNameUsedInTwoClassificationsDeleteAllNodes(){
commitAndStartNewTransaction(null);
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator();
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testDeleteTaxonNameUsedInTwoClassificationsDoNotDeleteAllNodes(){
// delete the taxon only in second classification, this should delete only the nodes, not the taxa
Taxon testTaxon = getTestTaxon();
assertNotNull(tax);
Taxon childTaxon = (Taxon)service.find(childUUID);
assertNotNull(tax);
+ //when calling delete taxon and the taxon can not be deleted the children should not be deleted as well. If children should be deleted call delete taxonnode
node = nodeService.find(childNodeUUID);
- assertNull(node);
+ assertNotNull(node);
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonNodeDeletionConfiguratorMoveToParent(){
//test childHandling MOVE_TO_PARENT:
Taxon testTaxon = getTestTaxon();
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonNodeDeletionConfiguratorDeleteChildren(){
//test childHandling DELETE:
Taxon testTaxon = getTestTaxon();
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonDeletionConfiguratorDeleteMarker(){
//test childHandling DELETE:
Taxon testTaxon = getTestTaxon();
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonDeletionConfiguratorTaxonWithMisappliedName(){
Taxon testTaxon = getTestTaxon();
UUID misappliedNameUUID = service.save(misappliedName).getUuid();
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;
- config.setDeleteMisappliedNamesAndInvalidDesignations(true);
+ config.setDeleteMisappliedNames(true);
DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, node.getClassification().getUuid());
if(!result.isOk()){
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonDeletionConfiguratorTaxonWithMisappliedNameDoNotDelete(){
Taxon testTaxon = getTestTaxon();
UUID misappliedNameUUID = service.save(misappliedName).getUuid();
TaxonDeletionConfigurator config = new TaxonDeletionConfigurator() ;
- config.setDeleteMisappliedNamesAndInvalidDesignations(false);
+ config.setDeleteMisappliedNames(false);
DeleteResult result = service.deleteTaxon(testTaxon.getUuid(), config, node.getClassification().getUuid());
if(!result.isOk()){
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testTaxonDeletionConfiguratorTaxonMisappliedName(){
Taxon testTaxon = getTestTaxon();
}
@Test
- @DataSet(value="BlankDataSet.xml")
+ @DataSet(value="../../database/ClearDBDataSet.xml")
public final void testLlistIncludedTaxa(){
Reference citation = null;
String microcitation = null;
service.saveOrUpdate(c1Species);
service.saveOrUpdate(c2Species);
+ service.save(c4Species);
//Tests
//default starting at species 1
//same without doubtful
dto = service.listIncludedTaxa(c1Species.getUuid(), new IncludedTaxonConfiguration(null, false, true));
Assert.assertEquals(1, dto.getIncludedTaxa().size());
-
-
-
-
}
@Test
genusTaxon.setUuid(GENUS_UUID);
service.save(genusTaxon);
//a name that is the basionym of genusTaxon's name
- TaxonNameBase basionym = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonName basionym = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
basionym.setTitleCache("Hieracilla DC.", true);
basionym.setGenusOrUninomial("Hieracilla");
basionym.setCombinationAuthorship(deCandolle);
basionym.setUuid(BASIONYM_UUID);
- botName.addBasionym(basionym, null, null,"216");
+ botName.addBasionym(basionym, null, null,"216", null);
nameService.saveOrUpdate(basionym);
//species taxon that is the child of genus taxon
IBotanicalName botSpecies = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
missName.setSpecificEpithet("lupium");
missName.setCombinationAuthorship(deCandolle);
missName.setUuid(SPECIES5_NAME_UUID);
- Taxon misappliedName = Taxon.NewInstance(missName, sec);
- childTaxon2.addMisappliedName(misappliedName, citationRef, "125");
+ Taxon misappliedNameTaxon = Taxon.NewInstance(missName, sec);
+ childTaxon2.addMisappliedName(misappliedNameTaxon, citationRef, "125");
taxDesc = getTestDescription(descrIndex++);
// taxDesc.setUuid(DESCRIPTION2_UUID);
genusTaxon.addDescription(taxDesc);
service.saveOrUpdate(genusTaxon);
+ service.save(misappliedNameTaxon);
return genusTaxon;
}
BGBM BDI Projects / cdmlib.git / blobdiff