From 88a347d9780c25c360583e60005e0b9da8584ea0 Mon Sep 17 00:00:00 2001 From: Sandro La Bruzzo Date: Wed, 23 Feb 2022 10:42:23 +0100 Subject: [PATCH] implemented unitTest to verify if compare works --- .../schema/sx/scholix/ScholixCompareTest.java | 156 ++++++++++++++---- 1 file changed, 123 insertions(+), 33 deletions(-) diff --git a/src/test/java/eu/dnetlib/dhp/schema/sx/scholix/ScholixCompareTest.java b/src/test/java/eu/dnetlib/dhp/schema/sx/scholix/ScholixCompareTest.java index 53a489d..2762873 100644 --- a/src/test/java/eu/dnetlib/dhp/schema/sx/scholix/ScholixCompareTest.java +++ b/src/test/java/eu/dnetlib/dhp/schema/sx/scholix/ScholixCompareTest.java @@ -1,39 +1,34 @@ package eu.dnetlib.dhp.schema.sx.scholix; import org.junit.jupiter.api.Test; - import java.util.ArrayList; import java.util.List; - +import java.util.stream.Collectors; +import java.util.stream.IntStream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; public class ScholixCompareTest { + private ScholixIdentifier generateMockScholixId(final String baseId ,boolean toUpper, int idCount) { - - - - - - private ScholixIdentifier generateMockScholixId(boolean toUpper, int idCount) { - - final String id = String.format("10.11646/zootaxa.5099.1.%d", idCount); + final String id = String.format("%s.%d",baseId, idCount); final String schema = "DOI"; - final String url =String.format("http://dx.dOI.org/10.11646/Zootaxa.5099.1.%d", idCount); + final String url =String.format("http://dx.dOI.org/%s.%d",baseId, idCount); final ScholixIdentifier result = new ScholixIdentifier(); result.setIdentifier(toUpper ? id.toUpperCase(): id.toLowerCase()); result.setSchema(toUpper ? schema.toUpperCase():schema.toLowerCase()); result.setUrl(toUpper ? url.toUpperCase():url.toLowerCase()); return result; - } + private ScholixIdentifier generateMockScholixId(boolean toUpper, int idCount) { + return generateMockScholixId("10.11646/zootaxa.5099.1", toUpper, idCount); + } - private ScholixEntityId generateMockScholixEntityId(boolean toUpper, boolean invertOrder, int numberOfIds) { + private ScholixEntityId generateMockScholixEntityId(String name, boolean toUpper, boolean invertOrder, int numberOfIds) { - final String datasourceName = "Datacite"; final List ids = new ArrayList<>(); @@ -48,20 +43,30 @@ public class ScholixCompareTest { } } - return new ScholixEntityId(toUpper? datasourceName.toUpperCase(): datasourceName.toLowerCase(), ids); + return new ScholixEntityId(toUpper? name.toUpperCase(): name.toLowerCase(), ids); } - private ScholixCollectedFrom generateMockScholixCollectedFrom(boolean toUpper, boolean invertOrder, int numberOfIds) { + private ScholixEntityId generateMockScholixEntityId(boolean toUpper, boolean invertOrder, int numberOfIds) { + + return generateMockScholixEntityId("datacite", toUpper, invertOrder,numberOfIds); + } + + private ScholixCollectedFrom generateMockScholixCollectedFrom(final String dsName , final boolean toUpper, final boolean invertOrder, final int numberOfIds) { final ScholixCollectedFrom result = new ScholixCollectedFrom(); final String completionStatus = "complete"; final String provisionMode = "collected"; - result.setProvider(generateMockScholixEntityId(toUpper, invertOrder, numberOfIds)); + result.setProvider(generateMockScholixEntityId(dsName,toUpper, invertOrder, numberOfIds)); result.setCompletionStatus(toUpper ? completionStatus.toUpperCase(): completionStatus.toLowerCase()); result.setProvisionMode(toUpper ? provisionMode.toUpperCase(): provisionMode.toLowerCase()); return result; } + + private ScholixCollectedFrom generateMockScholixCollectedFrom(boolean toUpper, boolean invertOrder, int numberOfIds) { + return generateMockScholixCollectedFrom("datasource", toUpper, invertOrder,numberOfIds); + } + private ScholixRelationship generateMockScholixRelationships(boolean toUpper) { final String name = "IsRelatedTo"; @@ -78,26 +83,86 @@ public class ScholixCompareTest { } + private ScholixResource generateMockScholixResource(final String sourceBase, boolean toUpper, int idCount, boolean invertOrder, int numEntityIds) { + final ScholixResource resource = new ScholixResource(); + final String baseSourceId = "%s_10.1000/ID_%d/"; + final String creatorBase ="Creator %d"; + final String publisherBase ="Publisher %d"; + final String collectedFromBase ="Datasource %d"; + final String title = String.format("Resource %s Title 1", sourceBase); + final List ids = IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(baseSourceId,sourceBase, i)) + .map(s ->generateMockScholixId(s, toUpper, idCount)) + .collect(Collectors.toList()); + resource.setIdentifier(ids); + resource.setDnetIdentifier("dnetId"); + + resource.setObjectType("dataset"); + resource.setObjectSubType("dataset"); + resource.setTitle(title); + final List creators = IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(creatorBase, i)) + .map(s ->generateMockScholixEntityId(s, toUpper,invertOrder,idCount)) + .collect(Collectors.toList()); + resource.setCreator(creators); + resource.setPublicationDate("22-02-2022"); + + + final List publishers = IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(publisherBase, i)) + .map(s ->generateMockScholixEntityId(s, toUpper,invertOrder,idCount)) + .collect(Collectors.toList()); + resource.setPublisher(publishers); + + + final List collectedFroms = IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(collectedFromBase, i)) + .map(s -> generateMockScholixCollectedFrom(s,toUpper, invertOrder, idCount)) + .collect(Collectors.toList()); + + resource.setCollectedFrom(collectedFroms); + return resource; + } + + + + private Scholix generateMockScholix( boolean toUpper, int idCount, boolean invertOrder, int numEntityIds) { + final Scholix result = new Scholix(); + result.setPublicationDate("2022-02-22"); + + final String id = "dnetID"; + final String publisherBase ="Publisher %d"; + + result.setPublisher(IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(publisherBase, i)) + .map(s ->generateMockScholixEntityId(s, toUpper,invertOrder,idCount)) + .collect(Collectors.toList())); + + result.setLinkprovider(IntStream.range(0,numEntityIds) + .mapToObj(i -> String.format(publisherBase, i)) + .map(s ->generateMockScholixEntityId(s, toUpper,invertOrder,idCount)) + .collect(Collectors.toList())); + + result.setRelationship(generateMockScholixRelationships(toUpper)); + result.setSource(generateMockScholixResource("source", toUpper, idCount,invertOrder, numEntityIds)); + result.setTarget(generateMockScholixResource("target", toUpper, idCount,invertOrder, numEntityIds)); + + result.setIdentifier(toUpper?id.toUpperCase():id.toLowerCase()); + return result; + } + + @Test public void testScholixIdentifierComparison() { final ScholixIdentifier left = generateMockScholixId(true, 1); - - final ScholixIdentifier right = generateMockScholixId(false,1); - assertEquals(0,left.compareTo(right)); - assertEquals(left, right); assertEquals(left.hashCode(), right.hashCode()); - - left.setIdentifier(null); - assertEquals(-1, left.compareTo(right)); - - } @@ -116,8 +181,6 @@ public class ScholixCompareTest { public void testScholixCollectedFromComparison() { final ScholixCollectedFrom cfLeft = generateMockScholixCollectedFrom(true, true, 20); - - final ScholixCollectedFrom cfRight = generateMockScholixCollectedFrom(false, false, 20); assertEquals(cfLeft, cfRight); @@ -127,6 +190,35 @@ public class ScholixCompareTest { cfRight.setCompletionStatus(null); assertNotEquals(cfLeft, cfRight); + } + + @Test + public void testCompareScholixResource() { + final ScholixResource left = generateMockScholixResource("source",true,5, true,5); + final ScholixResource right = generateMockScholixResource("source",false,5, false,5); + assertEquals(left,right); + assertEquals(left.hashCode(), right.hashCode()); + final ScholixResource different = generateMockScholixResource("source",false,4, false,5); + assertNotEquals(different,right); + assertNotEquals(different,left); + assertNotEquals(left.hashCode(), different.hashCode()); + assertNotEquals(right.hashCode(), different.hashCode()); + } + + + @Test + public void testCompareScholix() { + + final Scholix left = generateMockScholix(true,5, true,5); + final Scholix right = generateMockScholix(false,5, false,5); + assertEquals(left,right); + assertEquals(left.hashCode(), right.hashCode()); + final Scholix different = generateMockScholix(true,4, false,5); + + assertNotEquals(different,right); + assertNotEquals(different,left); + assertNotEquals(left.hashCode(), different.hashCode()); + assertNotEquals(right.hashCode(), different.hashCode()); } @@ -134,16 +226,14 @@ public class ScholixCompareTest { @Test public void testCompareScholixRelation() { - - final ScholixRelationship left = generateMockScholixRelationships(true); final ScholixRelationship right = generateMockScholixRelationships(false); - assertEquals(left, right); assertEquals(left.hashCode(), right.hashCode()); - - } + + + }