2020-04-27 14:52:31 +02:00
|
|
|
|
2020-04-10 17:53:07 +02:00
|
|
|
package eu.dnetlib.dhp.oa.graph.raw;
|
2020-03-27 11:46:37 +01:00
|
|
|
|
2020-04-18 12:42:58 +02:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
2020-06-10 10:04:00 +02:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
2020-04-20 18:53:06 +02:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
2020-04-18 12:42:58 +02:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
2020-07-20 17:33:37 +02:00
|
|
|
import static org.mockito.Mockito.lenient;
|
2020-04-18 12:42:58 +02:00
|
|
|
|
|
|
|
import java.io.IOException;
|
|
|
|
import java.util.List;
|
2020-05-15 12:26:16 +02:00
|
|
|
import java.util.Optional;
|
2020-04-28 11:23:29 +02:00
|
|
|
|
2020-03-27 11:46:37 +01:00
|
|
|
import org.apache.commons.io.IOUtils;
|
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
|
import org.junit.jupiter.api.BeforeEach;
|
|
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
import org.junit.jupiter.api.extension.ExtendWith;
|
|
|
|
import org.mockito.Mock;
|
|
|
|
import org.mockito.junit.jupiter.MockitoExtension;
|
|
|
|
|
2020-07-28 12:02:15 +02:00
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
|
|
|
2021-01-25 15:43:04 +01:00
|
|
|
import eu.dnetlib.dhp.common.vocabulary.VocabularyGroup;
|
2020-07-20 17:37:08 +02:00
|
|
|
import eu.dnetlib.dhp.oa.graph.clean.CleaningFunctionTest;
|
2020-05-15 15:16:54 +02:00
|
|
|
import eu.dnetlib.dhp.schema.common.ModelConstants;
|
2020-05-22 11:00:27 +02:00
|
|
|
import eu.dnetlib.dhp.schema.oaf.Author;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Dataset;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Field;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Oaf;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Publication;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Relation;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.Software;
|
|
|
|
import eu.dnetlib.dhp.schema.oaf.StructuredProperty;
|
2020-07-20 17:37:08 +02:00
|
|
|
import eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService;
|
2020-05-15 15:16:54 +02:00
|
|
|
|
2020-03-27 11:46:37 +01:00
|
|
|
@ExtendWith(MockitoExtension.class)
|
|
|
|
public class MappersTest {
|
|
|
|
|
2020-07-20 17:33:37 +02:00
|
|
|
@Mock
|
|
|
|
private ISLookUpService isLookUpService;
|
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
@Mock
|
2020-05-27 11:34:13 +02:00
|
|
|
private VocabularyGroup vocs;
|
2020-04-27 14:52:31 +02:00
|
|
|
|
|
|
|
@BeforeEach
|
|
|
|
public void setUp() throws Exception {
|
2020-07-20 17:33:37 +02:00
|
|
|
lenient().when(isLookUpService.quickSearchProfile(VocabularyGroup.VOCABULARIES_XQUERY)).thenReturn(vocs());
|
|
|
|
lenient()
|
2020-07-20 17:37:08 +02:00
|
|
|
.when(isLookUpService.quickSearchProfile(VocabularyGroup.VOCABULARY_SYNONYMS_XQUERY))
|
|
|
|
.thenReturn(synonyms());
|
2020-05-27 11:34:13 +02:00
|
|
|
|
2020-07-20 17:33:37 +02:00
|
|
|
vocs = VocabularyGroup.loadVocsFromIS(isLookUpService);
|
2020-04-27 14:52:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
void testPublication() throws IOException {
|
2020-05-27 11:34:13 +02:00
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf_record.xml"));
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-04-27 14:52:31 +02:00
|
|
|
|
|
|
|
assertEquals(3, list.size());
|
|
|
|
assertTrue(list.get(0) instanceof Publication);
|
|
|
|
assertTrue(list.get(1) instanceof Relation);
|
|
|
|
assertTrue(list.get(2) instanceof Relation);
|
|
|
|
|
|
|
|
final Publication p = (Publication) list.get(0);
|
|
|
|
final Relation r1 = (Relation) list.get(1);
|
|
|
|
final Relation r2 = (Relation) list.get(2);
|
|
|
|
|
|
|
|
assertValidId(p.getId());
|
2020-07-20 09:50:29 +02:00
|
|
|
|
2021-03-09 17:11:50 +01:00
|
|
|
assertEquals(1, p.getOriginalId().size());
|
2021-03-09 09:12:41 +01:00
|
|
|
assertTrue(p.getOriginalId().contains("10.3897/oneeco.2.e13718"));
|
2020-07-20 09:50:29 +02:00
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
2020-06-10 10:04:00 +02:00
|
|
|
assertFalse(p.getDataInfo().getInvisible());
|
2020-07-17 12:25:36 +02:00
|
|
|
assertTrue(p.getSource().size() == 1);
|
2020-11-18 09:26:20 +01:00
|
|
|
assertTrue(StringUtils.isNotBlank(p.getDateofcollection()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getDateoftransformation()));
|
2020-05-15 12:26:16 +02:00
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
assertTrue(p.getAuthor().size() > 0);
|
2020-05-22 11:00:27 +02:00
|
|
|
final Optional<Author> author = p
|
2020-05-15 15:16:54 +02:00
|
|
|
.getAuthor()
|
|
|
|
.stream()
|
|
|
|
.filter(a -> a.getPid() != null && !a.getPid().isEmpty())
|
|
|
|
.findFirst();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertTrue(author.isPresent());
|
2020-07-17 12:25:36 +02:00
|
|
|
|
2020-05-22 11:00:27 +02:00
|
|
|
final StructuredProperty pid = author
|
2020-05-15 15:16:54 +02:00
|
|
|
.get()
|
|
|
|
.getPid()
|
|
|
|
.stream()
|
|
|
|
.findFirst()
|
|
|
|
.get();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertEquals("0000-0001-6651-1178", pid.getValue());
|
|
|
|
assertEquals("ORCID", pid.getQualifier().getClassid());
|
2020-05-22 12:25:01 +02:00
|
|
|
assertEquals("Open Researcher and Contributor ID", pid.getQualifier().getClassname());
|
2020-05-15 12:26:16 +02:00
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemeid());
|
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemename());
|
|
|
|
assertEquals("Votsi,Nefta", author.get().getFullname());
|
|
|
|
assertEquals("Votsi", author.get().getSurname());
|
|
|
|
assertEquals("Nefta", author.get().getName());
|
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
assertTrue(p.getSubject().size() > 0);
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getJournal().getIssnOnline()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getJournal().getName()));
|
|
|
|
|
2021-03-17 12:45:38 +01:00
|
|
|
assertTrue(p.getPid().isEmpty());
|
2020-05-27 11:34:13 +02:00
|
|
|
|
2020-05-23 09:57:39 +02:00
|
|
|
assertNotNull(p.getInstance());
|
|
|
|
assertTrue(p.getInstance().size() > 0);
|
2020-05-23 10:21:19 +02:00
|
|
|
p
|
|
|
|
.getInstance()
|
|
|
|
.stream()
|
|
|
|
.forEach(i -> {
|
|
|
|
assertNotNull(i.getAccessright());
|
|
|
|
assertEquals("OPEN", i.getAccessright().getClassid());
|
|
|
|
});
|
2020-06-23 10:14:39 +02:00
|
|
|
assertEquals("0001", p.getInstance().get(0).getRefereed().getClassid());
|
2021-01-11 17:15:18 +01:00
|
|
|
assertNotNull(p.getInstance().get(0).getPid());
|
2021-03-16 14:19:32 +01:00
|
|
|
assertTrue(p.getInstance().get(0).getPid().isEmpty());
|
|
|
|
|
|
|
|
assertTrue(!p.getInstance().get(0).getAlternateIdentifier().isEmpty());
|
|
|
|
assertEquals("doi", p.getInstance().get(0).getAlternateIdentifier().get(0).getQualifier().getClassid());
|
|
|
|
assertEquals("10.3897/oneeco.2.e13718", p.getInstance().get(0).getAlternateIdentifier().get(0).getValue());
|
2020-05-23 09:57:39 +02:00
|
|
|
|
|
|
|
assertNotNull(p.getBestaccessright());
|
|
|
|
assertEquals("OPEN", p.getBestaccessright().getClassid());
|
2020-04-27 14:52:31 +02:00
|
|
|
assertValidId(r1.getSource());
|
|
|
|
assertValidId(r1.getTarget());
|
|
|
|
assertValidId(r2.getSource());
|
|
|
|
assertValidId(r2.getTarget());
|
|
|
|
assertValidId(r1.getCollectedfrom().get(0).getKey());
|
|
|
|
assertValidId(r2.getCollectedfrom().get(0).getKey());
|
|
|
|
assertNotNull(r1.getDataInfo());
|
|
|
|
assertNotNull(r2.getDataInfo());
|
|
|
|
assertNotNull(r1.getDataInfo().getTrust());
|
|
|
|
assertNotNull(r2.getDataInfo().getTrust());
|
|
|
|
assertEquals(r1.getSource(), r2.getTarget());
|
|
|
|
assertEquals(r2.getSource(), r1.getTarget());
|
|
|
|
assertTrue(StringUtils.isNotBlank(r1.getRelClass()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r2.getRelClass()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r1.getRelType()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r2.getRelType()));
|
2020-12-09 11:18:26 +01:00
|
|
|
assertTrue(r1.getValidated());
|
|
|
|
assertTrue(r2.getValidated());
|
|
|
|
assertEquals(r1.getValidationDate(), "2020-01-01");
|
|
|
|
assertEquals(r2.getValidationDate(), "2020-01-01");
|
2020-05-27 11:34:13 +02:00
|
|
|
// System.out.println(new ObjectMapper().writeValueAsString(p));
|
2020-04-27 14:52:31 +02:00
|
|
|
// System.out.println(new ObjectMapper().writeValueAsString(r1));
|
|
|
|
// System.out.println(new ObjectMapper().writeValueAsString(r2));
|
|
|
|
}
|
|
|
|
|
2021-03-16 14:19:32 +01:00
|
|
|
@Test
|
|
|
|
void testPublication_PubMed() throws IOException {
|
|
|
|
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf_record_pubmed.xml"));
|
|
|
|
|
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, false, true).processMdRecord(xml);
|
|
|
|
|
|
|
|
assertEquals(1, list.size());
|
|
|
|
assertTrue(list.get(0) instanceof Publication);
|
|
|
|
|
|
|
|
final Publication p = (Publication) list.get(0);
|
|
|
|
|
|
|
|
assertValidId(p.getId());
|
|
|
|
|
|
|
|
assertEquals(2, p.getOriginalId().size());
|
|
|
|
assertTrue(p.getOriginalId().contains("oai:pubmedcentral.nih.gov:1517292"));
|
|
|
|
|
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
|
|
|
assertFalse(p.getDataInfo().getInvisible());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getDateofcollection()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getDateoftransformation()));
|
|
|
|
|
|
|
|
assertTrue(p.getAuthor().size() > 0);
|
|
|
|
final Optional<Author> author = p
|
|
|
|
.getAuthor()
|
|
|
|
.stream()
|
|
|
|
.filter(a -> a.getPid() != null && !a.getPid().isEmpty())
|
|
|
|
.findFirst();
|
|
|
|
assertTrue(author.isPresent());
|
|
|
|
|
|
|
|
final StructuredProperty pid = author
|
|
|
|
.get()
|
|
|
|
.getPid()
|
|
|
|
.stream()
|
|
|
|
.findFirst()
|
|
|
|
.get();
|
|
|
|
assertEquals("0000-0001-6651-1178", pid.getValue());
|
|
|
|
assertEquals("ORCID", pid.getQualifier().getClassid());
|
|
|
|
assertEquals("Open Researcher and Contributor ID", pid.getQualifier().getClassname());
|
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemeid());
|
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemename());
|
|
|
|
assertEquals("Votsi,Nefta", author.get().getFullname());
|
|
|
|
assertEquals("Votsi", author.get().getSurname());
|
|
|
|
assertEquals("Nefta", author.get().getName());
|
|
|
|
|
|
|
|
assertTrue(p.getSubject().size() > 0);
|
|
|
|
assertTrue(p.getPid().size() > 0);
|
|
|
|
assertEquals(p.getPid().get(0).getValue(), "PMC1517292");
|
|
|
|
assertEquals(p.getPid().get(0).getQualifier().getClassid(), "pmc");
|
|
|
|
|
|
|
|
assertNotNull(p.getInstance());
|
|
|
|
assertTrue(p.getInstance().size() > 0);
|
|
|
|
p
|
|
|
|
.getInstance()
|
|
|
|
.stream()
|
|
|
|
.forEach(i -> {
|
|
|
|
assertNotNull(i.getAccessright());
|
|
|
|
assertEquals("OPEN", i.getAccessright().getClassid());
|
|
|
|
});
|
|
|
|
assertEquals("UNKNOWN", p.getInstance().get(0).getRefereed().getClassid());
|
|
|
|
assertNotNull(p.getInstance().get(0).getPid());
|
|
|
|
assertTrue(p.getInstance().get(0).getPid().size() == 2);
|
|
|
|
|
|
|
|
assertTrue(p.getInstance().get(0).getAlternateIdentifier().size() == 1);
|
|
|
|
assertEquals("doi", p.getInstance().get(0).getAlternateIdentifier().get(0).getQualifier().getClassid());
|
|
|
|
assertEquals("10.3897/oneeco.2.e13718", p.getInstance().get(0).getAlternateIdentifier().get(0).getValue());
|
|
|
|
|
|
|
|
assertNotNull(p.getBestaccessright());
|
|
|
|
assertEquals("OPEN", p.getBestaccessright().getClassid());
|
|
|
|
}
|
|
|
|
|
2020-06-10 10:04:00 +02:00
|
|
|
@Test
|
|
|
|
void testPublicationInvisible() throws IOException {
|
|
|
|
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf_record.xml"));
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, true, true).processMdRecord(xml);
|
2020-06-10 10:04:00 +02:00
|
|
|
|
|
|
|
assertTrue(list.size() > 0);
|
|
|
|
assertTrue(list.get(0) instanceof Publication);
|
|
|
|
|
|
|
|
final Publication p = (Publication) list.get(0);
|
|
|
|
|
|
|
|
assertTrue(p.getDataInfo().getInvisible());
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
@Test
|
|
|
|
void testDataset() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("odf_dataset.xml"));
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-04-27 14:52:31 +02:00
|
|
|
|
|
|
|
assertEquals(3, list.size());
|
|
|
|
assertTrue(list.get(0) instanceof Dataset);
|
|
|
|
assertTrue(list.get(1) instanceof Relation);
|
|
|
|
assertTrue(list.get(2) instanceof Relation);
|
|
|
|
|
|
|
|
final Dataset d = (Dataset) list.get(0);
|
|
|
|
final Relation r1 = (Relation) list.get(1);
|
|
|
|
final Relation r2 = (Relation) list.get(2);
|
|
|
|
|
|
|
|
assertValidId(d.getId());
|
2021-03-09 17:11:50 +01:00
|
|
|
assertEquals(1, d.getOriginalId().size());
|
2021-03-09 09:12:41 +01:00
|
|
|
assertTrue(d.getOriginalId().contains("oai:zenodo.org:3234526"));
|
2020-04-27 14:52:31 +02:00
|
|
|
assertValidId(d.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(d.getTitle().get(0).getValue()));
|
|
|
|
assertTrue(d.getAuthor().size() > 0);
|
2020-05-15 12:26:16 +02:00
|
|
|
|
2020-05-22 11:00:27 +02:00
|
|
|
final Optional<Author> author = d
|
2020-05-15 15:16:54 +02:00
|
|
|
.getAuthor()
|
|
|
|
.stream()
|
|
|
|
.filter(a -> a.getPid() != null && !a.getPid().isEmpty())
|
|
|
|
.findFirst();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertTrue(author.isPresent());
|
2020-05-22 11:00:27 +02:00
|
|
|
final StructuredProperty pid = author
|
2020-05-15 15:16:54 +02:00
|
|
|
.get()
|
|
|
|
.getPid()
|
|
|
|
.stream()
|
|
|
|
.findFirst()
|
|
|
|
.get();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertEquals("0000-0001-9074-1619", pid.getValue());
|
|
|
|
assertEquals("ORCID", pid.getQualifier().getClassid());
|
2020-05-22 11:00:27 +02:00
|
|
|
assertEquals("Open Researcher and Contributor ID", pid.getQualifier().getClassname());
|
2020-05-15 12:26:16 +02:00
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemeid());
|
|
|
|
assertEquals(ModelConstants.DNET_PID_TYPES, pid.getQualifier().getSchemename());
|
|
|
|
assertEquals("Baracchini, Theo", author.get().getFullname());
|
|
|
|
assertEquals("Baracchini", author.get().getSurname());
|
|
|
|
assertEquals("Theo", author.get().getName());
|
|
|
|
|
|
|
|
assertEquals(1, author.get().getAffiliation().size());
|
2020-05-22 11:00:27 +02:00
|
|
|
final Optional<Field<String>> opAff = author
|
2020-05-15 15:16:54 +02:00
|
|
|
.get()
|
|
|
|
.getAffiliation()
|
|
|
|
.stream()
|
|
|
|
.findFirst();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertTrue(opAff.isPresent());
|
2020-05-22 11:00:27 +02:00
|
|
|
final Field<String> affiliation = opAff.get();
|
2020-05-15 12:26:16 +02:00
|
|
|
assertEquals("ISTI-CNR", affiliation.getValue());
|
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
assertTrue(d.getSubject().size() > 0);
|
|
|
|
assertTrue(d.getInstance().size() > 0);
|
|
|
|
assertTrue(d.getContext().size() > 0);
|
|
|
|
assertTrue(d.getContext().get(0).getId().length() > 0);
|
|
|
|
|
2020-05-23 09:57:39 +02:00
|
|
|
assertNotNull(d.getInstance());
|
|
|
|
assertTrue(d.getInstance().size() > 0);
|
2020-05-23 10:21:19 +02:00
|
|
|
d
|
|
|
|
.getInstance()
|
|
|
|
.stream()
|
|
|
|
.forEach(i -> {
|
|
|
|
assertNotNull(i.getAccessright());
|
|
|
|
assertEquals("OPEN", i.getAccessright().getClassid());
|
|
|
|
});
|
2020-06-23 10:14:39 +02:00
|
|
|
assertEquals("0001", d.getInstance().get(0).getRefereed().getClassid());
|
2021-01-11 17:15:18 +01:00
|
|
|
assertNotNull(d.getInstance().get(0).getPid());
|
2021-03-16 14:19:32 +01:00
|
|
|
assertTrue(d.getInstance().get(0).getPid().isEmpty());
|
|
|
|
|
|
|
|
assertEquals("doi", d.getInstance().get(0).getAlternateIdentifier().get(0).getQualifier().getClassid());
|
|
|
|
assertEquals("10.5281/zenodo.3234526", d.getInstance().get(0).getAlternateIdentifier().get(0).getValue());
|
2020-05-23 09:57:39 +02:00
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
assertValidId(r1.getSource());
|
|
|
|
assertValidId(r1.getTarget());
|
|
|
|
assertValidId(r2.getSource());
|
|
|
|
assertValidId(r2.getTarget());
|
|
|
|
assertNotNull(r1.getDataInfo());
|
|
|
|
assertNotNull(r2.getDataInfo());
|
|
|
|
assertNotNull(r1.getDataInfo().getTrust());
|
|
|
|
assertNotNull(r2.getDataInfo().getTrust());
|
|
|
|
assertEquals(r1.getSource(), r2.getTarget());
|
|
|
|
assertEquals(r2.getSource(), r1.getTarget());
|
|
|
|
assertTrue(StringUtils.isNotBlank(r1.getRelClass()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r2.getRelClass()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r1.getRelType()));
|
|
|
|
assertTrue(StringUtils.isNotBlank(r2.getRelType()));
|
2020-12-09 11:18:26 +01:00
|
|
|
assertTrue(r1.getValidated());
|
|
|
|
assertTrue(r2.getValidated());
|
|
|
|
assertEquals(r1.getValidationDate(), "2020-01-01");
|
|
|
|
assertEquals(r2.getValidationDate(), "2020-01-01");
|
2020-04-27 14:52:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
void testSoftware() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("odf_software.xml"));
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-04-27 14:52:31 +02:00
|
|
|
|
|
|
|
assertEquals(1, list.size());
|
|
|
|
assertTrue(list.get(0) instanceof Software);
|
|
|
|
|
|
|
|
final Software s = (Software) list.get(0);
|
|
|
|
|
|
|
|
assertValidId(s.getId());
|
|
|
|
assertValidId(s.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(s.getTitle().get(0).getValue()));
|
|
|
|
assertTrue(s.getAuthor().size() > 0);
|
|
|
|
assertTrue(s.getSubject().size() > 0);
|
|
|
|
assertTrue(s.getInstance().size() > 0);
|
|
|
|
}
|
|
|
|
|
2020-07-28 12:02:15 +02:00
|
|
|
// @Test
|
|
|
|
void testDataset_2() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("odf_dataset_2.xml"));
|
|
|
|
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-07-28 12:02:15 +02:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
}
|
|
|
|
|
2020-08-03 11:17:50 +02:00
|
|
|
@Test
|
|
|
|
void testClaimDedup() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf_claim_dedup.xml"));
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-08-03 11:17:50 +02:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
}
|
|
|
|
|
2020-08-04 12:50:52 +02:00
|
|
|
@Test
|
|
|
|
void testNakala() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("odf_nakala.xml"));
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-08-04 12:50:52 +02:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
|
|
|
|
assertEquals(1, list.size());
|
|
|
|
assertTrue(list.get(0) instanceof Dataset);
|
|
|
|
|
|
|
|
final Dataset d = (Dataset) list.get(0);
|
|
|
|
|
|
|
|
assertValidId(d.getId());
|
|
|
|
assertValidId(d.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(d.getTitle().get(0).getValue()));
|
|
|
|
assertEquals(1, d.getAuthor().size());
|
2020-10-19 17:46:14 +02:00
|
|
|
assertEquals(1, d.getSubject().size());
|
2020-08-04 12:50:52 +02:00
|
|
|
assertEquals(1, d.getInstance().size());
|
2021-03-17 12:45:38 +01:00
|
|
|
assertTrue(d.getPid().isEmpty());
|
|
|
|
|
|
|
|
assertTrue(d.getInstance().get(0).getPid().isEmpty());
|
|
|
|
assertEquals(1, d.getInstance().get(0).getAlternateIdentifier().size());
|
|
|
|
assertEquals("handle", d.getInstance().get(0).getAlternateIdentifier().get(0).getQualifier().getClassid());
|
|
|
|
|
2020-10-19 17:46:14 +02:00
|
|
|
assertNotNull(d.getInstance().get(0).getUrl());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
void testClaimFromCrossref() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf_claim_crossref.xml"));
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-10-19 17:46:14 +02:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
|
|
|
|
final Publication p = (Publication) list.get(0);
|
|
|
|
assertValidId(p.getId());
|
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
System.out.println(p.getTitle().get(0).getValue());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
void testODFRecord() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("odf_record.xml"));
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-10-19 17:46:14 +02:00
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
final Dataset p = (Dataset) list.get(0);
|
|
|
|
assertValidId(p.getId());
|
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
System.out.println(p.getTitle().get(0).getValue());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
2020-08-04 12:50:52 +02:00
|
|
|
}
|
|
|
|
|
2020-11-17 18:39:25 +01:00
|
|
|
@Test
|
|
|
|
void testTextGrid() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("textgrid.xml"));
|
2020-11-30 12:00:38 +01:00
|
|
|
final List<Oaf> list = new OdfToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-11-17 18:39:25 +01:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
|
|
|
|
final Dataset p = (Dataset) list.get(0);
|
|
|
|
assertValidId(p.getId());
|
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
2020-12-09 19:46:11 +01:00
|
|
|
assertEquals(1, p.getAuthor().size());
|
|
|
|
assertEquals("OPEN", p.getBestaccessright().getClassid());
|
2021-03-17 12:45:38 +01:00
|
|
|
|
|
|
|
assertTrue(p.getPid().isEmpty());
|
2020-12-09 19:46:11 +01:00
|
|
|
assertEquals("dataset", p.getResulttype().getClassname());
|
|
|
|
assertEquals(1, p.getInstance().size());
|
|
|
|
assertEquals("OPEN", p.getInstance().get(0).getAccessright().getClassid());
|
|
|
|
assertValidId(p.getInstance().get(0).getCollectedfrom().getKey());
|
|
|
|
assertValidId(p.getInstance().get(0).getHostedby().getKey());
|
2020-12-09 20:00:27 +01:00
|
|
|
assertEquals(
|
|
|
|
"http://creativecommons.org/licenses/by/3.0/de/legalcode", p.getInstance().get(0).getLicense().getValue());
|
2021-03-17 12:45:38 +01:00
|
|
|
|
|
|
|
assertEquals(1, p.getInstance().size());
|
|
|
|
assertEquals(1, p.getInstance().get(0).getAlternateIdentifier().size());
|
|
|
|
assertEquals("handle", p.getInstance().get(0).getAlternateIdentifier().get(0).getQualifier().getClassid());
|
|
|
|
assertEquals(
|
|
|
|
"hdl:11858/00-1734-0000-0003-EE73-2", p.getInstance().get(0).getAlternateIdentifier().get(0).getValue());
|
|
|
|
|
2020-12-09 19:46:11 +01:00
|
|
|
assertEquals(1, p.getInstance().get(0).getUrl().size());
|
2020-11-17 18:39:25 +01:00
|
|
|
}
|
|
|
|
|
2020-12-02 10:15:26 +01:00
|
|
|
@Test
|
|
|
|
void testBologna() throws IOException {
|
|
|
|
final String xml = IOUtils.toString(getClass().getResourceAsStream("oaf-bologna.xml"));
|
2021-03-08 15:44:34 +01:00
|
|
|
final List<Oaf> list = new OafToOafMapper(vocs, false, true).processMdRecord(xml);
|
2020-12-02 10:15:26 +01:00
|
|
|
|
|
|
|
System.out.println("***************");
|
|
|
|
System.out.println(new ObjectMapper().writeValueAsString(list));
|
|
|
|
System.out.println("***************");
|
|
|
|
|
|
|
|
final Publication p = (Publication) list.get(0);
|
|
|
|
assertValidId(p.getId());
|
|
|
|
assertValidId(p.getCollectedfrom().get(0).getKey());
|
|
|
|
System.out.println(p.getTitle().get(0).getValue());
|
|
|
|
assertTrue(StringUtils.isNotBlank(p.getTitle().get(0).getValue()));
|
2020-11-17 18:39:25 +01:00
|
|
|
System.out.println(p.getTitle().get(0).getValue());
|
|
|
|
}
|
|
|
|
|
2020-04-27 14:52:31 +02:00
|
|
|
private void assertValidId(final String id) {
|
|
|
|
assertEquals(49, id.length());
|
|
|
|
assertEquals('|', id.charAt(2));
|
|
|
|
assertEquals(':', id.charAt(15));
|
|
|
|
assertEquals(':', id.charAt(16));
|
|
|
|
}
|
2020-07-20 17:33:37 +02:00
|
|
|
|
|
|
|
private List<String> vocs() throws IOException {
|
|
|
|
return IOUtils
|
2020-07-20 17:37:08 +02:00
|
|
|
.readLines(CleaningFunctionTest.class.getResourceAsStream("/eu/dnetlib/dhp/oa/graph/clean/terms.txt"));
|
2020-07-20 17:33:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private List<String> synonyms() throws IOException {
|
|
|
|
return IOUtils
|
2020-07-20 17:37:08 +02:00
|
|
|
.readLines(CleaningFunctionTest.class.getResourceAsStream("/eu/dnetlib/dhp/oa/graph/clean/synonyms.txt"));
|
2020-07-20 17:33:37 +02:00
|
|
|
}
|
|
|
|
|
2020-03-27 11:46:37 +01:00
|
|
|
}
|