import static org.junit.Assert.assertTrue;
import java.io.FileNotFoundException;
+import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.UUID;
-import org.apache.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import eu.etaxonomy.cdm.api.service.config.NameDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.pager.Pager;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
+import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.Rank;
/**
* @author a.mueller
- *
*/
public class NameServiceImplTest extends CdmTransactionalIntegrationTest {
- private static final Logger logger = Logger.getLogger(NameServiceImplTest.class);
+
+ private static final Logger logger = LogManager.getLogger();
+
+ private static final UUID NAME1_UUID = UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384");
+ private static final int NAME1_ID = 10;
+ private static final UUID NAME2_UUID = UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e");
+ private static final int NAME2_ID = 11;
+ private static final UUID NAME3_UUID = UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28");
+ private static final int NAME3_ID = 12;
@SpringBeanByType
private INameService nameService;
@SpringBeanByName
private AuthenticationManager authenticationManager;
+
private void setAuthentication(AbstractAuthenticationToken token) {
Authentication authentication = authenticationManager.authenticate(token);
secureContext.setAuthentication(null);
}
-
/* ******************** TESTS ********************************************/
/**
public void testDeleteTaxonNameWithNameRelations() {
final String[] tableNames = new String[]{"USERACCOUNT", "TaxonName","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
-// printDataSetWithNull(System.err, true, null);
+// printDataSet(System.err, true, null);
TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
nameWithBasionym.setTitleCache("nameWithBasionym", true);
NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
- name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
+ name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null, null);
// nameWithBasionym.addBasionym(name1);
nameService.save(name1);
nameService.save(nameWithBasionym);
nameWithBasionym.setTitleCache("nameWithBasionym", true);
NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
- name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
+ name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null, null);
nameService.save(name1);
nameService.save(nameWithBasionym);
commitAndStartNewTransaction(tableNames);
nameWithBasionym.setTitleCache("nameWithBasionym", true);
NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
- name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null);
+ name1.addRelationshipToName(nameWithBasionym,nameRelType , null, null, null, null);
nameService.save(name1);
nameService.save(nameWithBasionym);
commitAndStartNewTransaction(tableNames);
commitAndStartNewTransaction(tableNames);
name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
-
}
@Test
basionym.setTitleCache("basionym", true);
NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
- basionym.addRelationshipToName(name1,nameRelType , null, null, null);
+ basionym.addRelationshipToName(name1,nameRelType , null, null, null, null);
nameService.save(name1);
nameService.save(basionym);
commitAndStartNewTransaction(tableNames);
NameDeletionConfigurator config = new NameDeletionConfigurator();
config.setIgnoreHasBasionym(false);
- name1 = nameService.find(name1.getUuid());
- DeleteResult result = nameService.delete(name1.getUuid(), config);
- if (result.isOk()){
- Assert.fail("Delete should throw an error as long as name relationships exist.");
+ name1 = nameService.find(name1.getUuid());
+ DeleteResult result = nameService.delete(name1.getUuid(), config);
+ if (result.isOk()){
+ Assert.fail("Delete should throw an error as long as name relationships exist.");
}
-
name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
}
@Test
- // @Ignore //currently does not run in suite
public void testDeleteTaxonNameWithHybridRelations() {
final String[] tableNames = new String[]{"TaxonName","NameRelationship","HybridRelationship"};
Set<HybridRelationship> childRelations = hybrid.getHybridChildRelations();
for (HybridRelationship rel : childRelations){
- TaxonName name = rel.getHybridName();
- TaxonName parentName = rel.getParentName();
nameService.save(rel.getHybridName());
nameService.save(rel.getParentName());
}
-
-
commitAndStartNewTransaction(tableNames); //otherwise first save is rolled back with following failing delete
HybridRelationshipType relType = (HybridRelationshipType)termService.find(HybridRelationshipType.FIRST_PARENT().getUuid());
name1.addHybridParent(parent, relType, null);
name1 = nameService.find(name1.getUuid());
- nameService.delete(name1); //should throw now exception
+ nameService.delete(name1); //should throw now exception
setComplete();
endTransaction();
-// printDataSet(System.out, tableNames);
-
}
@Test
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
public void testDeleteTypeDesignation() {
- final String[] tableNames = new String[]{
- "TaxonName","TypeDesignationBase","TaxonName_TypeDesignationBase",
- "SpecimenOrObservationBase"};
-
-// IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
-// name1.setTitleCache("Name1");
-// name1.setUuid(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
-//
-// IBotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
-// name2.setTitleCache("Name2");
-// name2.setUuid(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
-//
-// IBotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
-// name3.setTitleCache("Name3");
-// name3.setUuid(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
-//
-//
-// SpecimenTypeDesignation desig1 = SpecimenTypeDesignation.NewInstance();
-// desig1.setUuid(UUID.fromString("1357c307-00c3-499c-8e20-0849d4706125"));
-// name1.addTypeDesignation(desig1, true);
-// name2.addTypeDesignation(desig1, true);
-//
-// SpecimenTypeDesignation desig2 = SpecimenTypeDesignation.NewInstance();
-// desig2.setUuid(UUID.fromString("9bbda70b-7272-4e65-a807-852a3f2eba63"));
-// name1.addTypeDesignation(desig2, true);
-//
-// Specimen specimen1 = Specimen.NewInstance();
-// Fossil specimen2 = Fossil.NewInstance();
-//
-// desig1.setTypeSpecimen(specimen1);
-// desig2.setTypeSpecimen(specimen2);
-//
-// NameTypeDesignation nameDesig = NameTypeDesignation.NewInstance();
-// nameDesig.setTypeName(name1);
-// name3.addTypeDesignation(nameDesig, true);
-//
-// nameService.save(name1);
-// nameService.save(name2);
-// nameService.save(name3);
-//
-// commitAndStartNewTransaction(tableNames);
-//
-// printDataSet(System.out, tableNames);
-//
+// final String[] tableNames = new String[]{
+// "TaxonName","TypeDesignationBase","TaxonName_TypeDesignationBase",
+// "SpecimenOrObservationBase"};
TaxonName name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
TaxonName name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
DerivedUnit specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
DerivedUnit fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
nameService.deleteTypeDesignation((TaxonName)null, null);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
nameService.deleteTypeDesignation(name1, null);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
SpecimenTypeDesignation desig2 = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
nameService.deleteTypeDesignation(name2, desig2);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
desigs3 = name3.getTypeDesignations();
- NameTypeDesignation desigNew = NameTypeDesignation.NewInstance();
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name3 = nameService.load(name3.getUuid());
Assert.assertEquals("name3 should have 2 type designations", 2, desigs3.size());
nameService.deleteTypeDesignation(name3, desig3);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
-
desigs1 = name1.getTypeDesignations();
desigs2 = name2.getTypeDesignations();
desigs3 = name3.getTypeDesignations();
Assert.assertEquals("name3 should have 0 type designations", 1, desigs3.size());
Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
Assert.assertEquals("Fossil should be used in 0 type designation", 0, fossil.getSpecimenTypeDesignations().size());
-
}
@Test
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class)
public void testDeleteTypeDesignationWithRegistration() {
- final String[] tableNames = new String[]{
- "TaxonName","TypeDesignationBase","TaxonName_TypeDesignationBase",
- "SpecimenOrObservationBase"};
+// final String[] tableNames = new String[]{
+// "TaxonName","TypeDesignationBase","TaxonName_TypeDesignationBase",
+// "SpecimenOrObservationBase"};
TaxonName name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
NameTypeDesignation desig3 = (NameTypeDesignation)name3.getTypeDesignations().iterator().next();
setAuthentication(submiterToken);
Registration registration = Registration.NewInstance("abc", "abc", name3, null);
registration.addTypeDesignation(desigNew);
- UUID uuidReg = registrationService.saveOrUpdate(registration);
+ registrationService.saveOrUpdate(registration);
unsetAuthentication();
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name3 = nameService.load(name3.getUuid());
Assert.assertEquals("registration should have 1 type designations",1, regs.iterator().next().getTypeDesignations().size());
nameService.deleteTypeDesignation(name3, desig3);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
desigs3 = name3.getTypeDesignations();
nameService.deleteTypeDesignation(name3, desigNew);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name3 = this.nameService.load(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
regs = name3.getRegistrations();
desigs3 = name3.getTypeDesignations();
Assert.assertEquals("registration should have 0 type designations",0, regs.iterator().next().getTypeDesignations().size());
}
-
@Test
@DataSet
public void testDeleteTypeDesignationAllNames() {
- final String[] tableNames = new String[]{
- "TaxonName","TypeDesignationBase",
- "TaxonName_TypeDesignationBase","SpecimenOrObservationBase"};
-
+// final String[] tableNames = new String[]{
+// "TaxonName","TypeDesignationBase",
+// "TaxonName_TypeDesignationBase","SpecimenOrObservationBase"};
TaxonName name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
TaxonName name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
DerivedUnit specimen1 = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("0d19a9ca-21a7-4adb-8640-8d6719e15eea")), DerivedUnit.class);
DerivedUnit fossil = CdmBase.deproxy(this.occurrenceService.load(UUID.fromString("4c48b7c8-4c8d-4e48-b083-0837fe51a0a9")), DerivedUnit.class);
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs1 = name1.getTypeDesignations();
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs2 = name2.getTypeDesignations();
+ @SuppressWarnings("rawtypes")
Set<TypeDesignationBase> desigs3 = name3.getTypeDesignations();
Assert.assertEquals("name1 should have 2 type designations", 2, desigs1.size());
nameService.deleteTypeDesignation(null, desig2);
- commitAndStartNewTransaction(tableNames);
+ commitAndStartNewTransaction(/*tableNames*/);
name1 = this.nameService.load(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
name2 = this.nameService.load(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
Assert.assertEquals("name3 should have 1 type designations", 1, desigs3.size());
Assert.assertEquals("Specimen1 should be used in 0 type designation", 0, specimen1.getSpecimenTypeDesignations().size());
Assert.assertEquals("Fossil should be used in 1 type designation", 1, fossil.getSpecimenTypeDesignations().size());
-
}
@Test
// -> SpecimenTypeDesignation -> Specimen2
// Name2 -> SpecimenTypeDesignation -> Specimen2
- // Logger.getLogger("org.hibernate.SQL").setLevel(Level.TRACE);
+// LogUtils.setLevel("org.hibernate.SQL", Level.TRACE);
List<Restriction<?>> restrictions;
result = nameService.findByTitleWithRestrictions(null, "Name2", MatchMode.EXACT, restrictions, null, null, null, null);
assertEquals(0l, result.getCount().longValue());
- // Logger.getLogger("eu.etaxonomy.cdm.persistence.dao.hibernate.common").setLevel(Level.DEBUG);
+ // LogUtils.setLevel("eu.etaxonomy.cdm.persistence.dao.hibernate.common", Level.DEBUG);
restrictions = Arrays.asList(new Restriction<String>("typeDesignations.typeSpecimen.titleCache", MatchMode.EXACT, "Specimen2"));
result = nameService.findByTitleWithRestrictions(null, "Name2", MatchMode.EXACT, restrictions, null, null, null, null);
restrictions = Arrays.asList(new Restriction<String>("typeDesignations.typeSpecimen.titleCache", MatchMode.BEGINNING, "Specimen"));
result = nameService.findByTitleWithRestrictions(null, "Name", MatchMode.BEGINNING, restrictions, null, null, null, null);
assertEquals(2l, result.getCount().longValue());
-
}
@Test
List<Restriction<?>> restrictions;
Pager<TaxonName> result;
- //Logger.getLogger("org.hibernate.SQL").setLevel(Level.TRACE);
+// LogUtils.setLevel("org.hibernate.SQL", Level.TRACE);
+
restrictions = Arrays.asList(new Restriction<String>("typeDesignations.typeName.titleCache", Operator.AND, null, "Name1"));
result = nameService.findByTitleWithRestrictions(null, "Name3", MatchMode.EXACT, restrictions, null, null, null, null);
result = nameService.findByTitleWithRestrictions(null, "Name", MatchMode.BEGINNING, restrictions, null, null, null, null);
assertEquals(2l, result.getCount().longValue());
+ restrictions = Arrays.asList(new Restriction<String>("titleCache", Operator.AND_NOT, null, "Name1", "Name2"));
+ result = nameService.findByTitleWithRestrictions(null, "Name", MatchMode.BEGINNING, restrictions, null, null, null, null);
+ assertEquals(1l, result.getCount().longValue());
+ assertEquals("Name3", result.getRecords().get(0).getTitleCache());
+
restrictions = Arrays.asList(new Restriction<String>("typeDesignations.typeName.titleCache", Operator.OR, null, "Name1"));
result = nameService.findByTitleWithRestrictions(null, "Name1", MatchMode.EXACT, restrictions, null, null, null, null);
assertEquals(2l, result.getCount().longValue());
restrictions = Arrays.asList(new Restriction<String>("typeDesignations.typeName.titleCache", Operator.OR_NOT, null, "Name1"));
result = nameService.findByTitleWithRestrictions(null, "Name1", MatchMode.EXACT, restrictions, null, null, null, null);
assertEquals(2l, result.getCount().longValue());
-
}
@Test
public void testFindByTitleTitle_using_Configurator(){
String searchString = "*";
- IdentifiableServiceConfiguratorImpl<TaxonName> searchConfigurator = new IdentifiableServiceConfiguratorImpl<TaxonName>();
+ IdentifiableServiceConfiguratorImpl<TaxonName> searchConfigurator = new IdentifiableServiceConfiguratorImpl<>();
searchConfigurator = IdentifiableServiceConfiguratorFactory.getConfigurator(TaxonName.class);
searchConfigurator.setTitleSearchString(searchString);
Pager<TaxonName> results = nameService.findByTitle(searchConfigurator);
assertTrue(results.getRecords().size() > 0);
+ }
+ @Test //7874 //8030
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="NameServiceImplTest.testUpdateCaches.xml")
+ public void testUpdateCaches() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
+
+ Field titleCacheField = IdentifiableEntity.class.getDeclaredField("titleCache");
+ titleCacheField.setAccessible(true);
+ Field nameCacheField = TaxonName.class.getDeclaredField("nameCache");
+ nameCacheField.setAccessible(true);
+ Field authorCacheField = TaxonName.class.getDeclaredField("authorshipCache");
+ authorCacheField.setAccessible(true);
+ Field fullTitleCacheField = TaxonName.class.getDeclaredField("fullTitleCache");
+ fullTitleCacheField.setAccessible(true);
+
+ TaxonName name1 = nameService.loadWithoutInitializing(NAME1_ID);
+ TaxonName name2 = nameService.loadWithoutInitializing(NAME2_ID);
+ TaxonName name3 = nameService.loadWithoutInitializing(NAME3_ID);
+
+ name1 = CdmBase.deproxy(name1);
+ assertEquals("TitleCache should be the persisted one", "Name1", titleCacheField.get(name1));
+ assertEquals("NameCache should be the persisted one", "", nameCacheField.get(name1));
+ assertEquals("AuthorCache should be the persisted one", "", authorCacheField.get(name1));
+ assertEquals("FullTitleCache should be the persisted one", "", fullTitleCacheField.get(name1));
+
+ name2 = CdmBase.deproxy(name2);
+ assertEquals("TitleCache should be the persisted one", "Name2", titleCacheField.get(name2));
+ assertEquals("NameCache should be the persisted one", "Protected name", nameCacheField.get(name2));
+ assertEquals("AuthorCache should be the persisted one", null, authorCacheField.get(name2));
+ assertEquals("FullTitleCache should be the persisted one", "", fullTitleCacheField.get(name2));
+
+ name3 = CdmBase.deproxy(name3);
+ assertEquals("TitleCache should be the persisted one", "Name3", titleCacheField.get(name3));
+ assertEquals("NameCache should be the persisted one", "", nameCacheField.get(name3));
+ assertEquals("AuthorCache should be the persisted one", "No-author", authorCacheField.get(name3));
+ assertEquals("FullTitleCache should be the persisted one", "", fullTitleCacheField.get(name3));
+
+ nameService.updateCaches();
+
+ assertEquals("Expecting titleCache to be updated", "First name Turl.", titleCacheField.get(name1));
+ assertEquals("Expecting nameCache to be updated", "First name", nameCacheField.get(name1));
+ assertEquals("Expecting authorshipCache to be updated", "Turl.", authorCacheField.get(name1));
+ assertEquals("Expecting fullTitleCache to be updated", "First name Turl.", fullTitleCacheField.get(name1));
+
+ assertEquals("Expecting titleCache to be updated", "Protected name", titleCacheField.get(name2));
+ assertEquals("Expecting nameCache to not be updated", "Protected name", nameCacheField.get(name2));
+ assertEquals("Expecting authorshipCache to be updated", "", authorCacheField.get(name2));
+ assertEquals("Expecting fullTitleCache to be updated", "Protected name", fullTitleCacheField.get(name2));
+
+ assertEquals("Expecting titleCache to be updated", "Name3", titleCacheField.get(name3));
+ assertEquals("Expecting nameCache to be updated", "Third", nameCacheField.get(name3));
+ assertEquals("Expecting authorshipCache to be updated", "No-author", authorCacheField.get(name3));
+ assertEquals("Expecting fullTitleCache to be updated", "Name3", fullTitleCacheField.get(name3));
+ }
+
+ @Test //#3666 and others
+ @DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="NameServiceImplTest.xml")
+ public void testParseName() {
+ Assert.assertEquals(3, nameService.count(TaxonName.class));
+ String nameToParseStr = "Abies alba Mill, Sp. Pl. 2: 333. 1751 [as \"alpa\"]";
+ TaxonName parsedName = (TaxonName)nameService.parseName(nameToParseStr, NomenclaturalCode.ICNAFP, Rank.SPECIES(), true).getCdmEntity();
+ UUID parsedNameUuid = parsedName.getUuid();
+ UUID originalSpellingUuid = parsedName.getOriginalSpelling().getUuid();
+ nameService.save(parsedName);
+
+ TaxonName parsedName2 = (TaxonName)nameService.parseName(nameToParseStr, NomenclaturalCode.ICNAFP, Rank.SPECIES(), true).getCdmEntity();
+ UUID parsedNameUuid2 = parsedName2.getUuid();
+ UUID originalSpelling2Uuid = parsedName2.getOriginalSpelling().getUuid();
+ Assert.assertEquals(originalSpellingUuid, originalSpelling2Uuid);
+ Assert.assertNotEquals(parsedNameUuid, parsedNameUuid2); //currently we do not deduplicate the main name yet
+
+ //tbc
}
private Rank getSpeciesRank() {
return (Rank)termService.find(Rank.uuidGenus);
}
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.test.integration.CdmIntegrationTest#createTestData()
- */
@Override
public void createTestDataSet() throws FileNotFoundException {}
-
-
-}
+}
\ No newline at end of file
BGBM BDI Projects / cdmlib.git / blobdiff