From fa3202358e56323cf30d7bef1172ce927aa42ed9 Mon Sep 17 00:00:00 2001 From: Nesta Bentum Date: Fri, 10 Jun 2022 13:05:32 +0200 Subject: [PATCH] Write ClusteringResult to Report --- .../reportobject/ReportObjectFactory.java | 22 +++++---- .../mapper/ClusteringResultMapper.java | 30 ++++++++++++ .../mapper/ClusteringResultMapperTest.java | 48 +++++++++++++++++++ 3 files changed, 91 insertions(+), 9 deletions(-) create mode 100644 jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapper.java create mode 100644 jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapperTest.java diff --git a/jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java b/jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java index ad97eb92c..a219b98cc 100644 --- a/jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java +++ b/jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java @@ -8,6 +8,7 @@ import java.util.*; import java.util.stream.Collectors; +import de.jplag.reporting.reportobject.mapper.ClusteringResultMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -21,9 +22,11 @@ public class ReportObjectFactory { private static final Logger logger = LoggerFactory.getLogger(ReportObjectFactory.class); + private static final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper(); /** * Converts a JPlagResult to a JPlagReport. + * * @return JPlagReport for the given JPlagResult. */ public static JPlagReport getReportObject(JPlagResult result) { @@ -58,13 +61,14 @@ private static OverviewReport generateOverviewReport(JPlagResult result) { overviewReport.setExecutionTime(result.getDuration()); overviewReport.setComparisonNames(getComparisonNames(comparisons)); overviewReport.setMetrics(getMetrics(result)); - overviewReport.setClusters(getClusters(result)); + overviewReport.setClusters(clusteringResultMapper.map(result)); return overviewReport; } /** * Generates detailed ComparisonReport DTO for each comparison in a JPlagResult. + * * @return A list with ComparisonReport DTOs. */ private static List generateComparisonReports(JPlagResult result) { @@ -87,6 +91,7 @@ private static List convertMatchesToReportMatches(JPlagResult result, JPl /** * Gets the names of all submissions. + * * @return A list containing all submission names. */ private static List extractSubmissionNames(List comparisons) { @@ -100,6 +105,7 @@ private static List extractSubmissionNames(List compari /** * Gets the names of all comparison. + * * @return A list containing all comparisons. */ private static List getComparisonNames(List comparisons) { @@ -113,6 +119,7 @@ private static List getComparisonNames(List comparisons /** * Gets the used metric in a JPlag comparison. + * * @return A list contains Metric DTOs. */ private static List getMetrics(JPlagResult result) { @@ -125,6 +132,7 @@ private static List getMetrics(JPlagResult result) { /** * Converts JPlagComparison to a DTO for displaying only comparisons. See * {@link #generateComparisonReports(JPlagResult)} for a more detailed representation of a comparison. + * * @return List containing TopComparison DTOs. */ private static List getTopComparisons(List comparisons) { @@ -136,6 +144,7 @@ private static List getTopComparisons(List compa /** * Converts files of a submission to FilesOFSubmission DTO. + * * @return A list containing FilesOfSubmission DTOs. */ private static List getFilesForSubmission(Submission submission) { @@ -144,9 +153,10 @@ private static List getFilesForSubmission(Submission submissi /** * Converts a JPlag Match object to a Match DTO. + * * @param comparison The comparison from which the match originates. - * @param match The match to be converted. - * @param usesIndex Indicates whether the language uses indexes. + * @param match The match to be converted. + * @param usesIndex Indicates whether the language uses indexes. * @return A Match DTO. */ private static Match convertMatchToReportMatch(JPlagComparison comparison, de.jplag.Match match, Boolean usesIndex) { @@ -166,12 +176,6 @@ private static Match convertMatchToReportMatch(JPlagComparison comparison, de.jp return new Match(startTokenFirst.getFile(), startTokenSecond.getFile(), startFirst, endFirst, startSecond, endSecond, tokens); } - // TODO implement after PR Read clustering #281 - private static List getClusters(JPlagResult result) { - // List> clusters = result.getClusteringResult(); - // return clusters.map( c -> new Cluster(getAvgSimilarity, getStrength, c.getMembers().map(Submission::getName))) - return List.of(); - } private static List readFileLines(File file) { List lines = new ArrayList<>(); diff --git a/jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapper.java b/jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapper.java new file mode 100644 index 000000000..fc89ffe3f --- /dev/null +++ b/jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapper.java @@ -0,0 +1,30 @@ +package de.jplag.reporting.reportobject.mapper; + +import de.jplag.JPlagResult; +import de.jplag.Submission; +import de.jplag.clustering.ClusteringResult; +import de.jplag.reporting.reportobject.model.Cluster; + +import java.util.Collection; +import java.util.List; + +/** + * Extracts and maps the clusters from the JPlagResult to the corresponding JSON DTO + */ +public class ClusteringResultMapper { + public List map(JPlagResult result) { + var clusteringResult = result.getClusteringResult(); + return clusteringResult.stream() + .map(ClusteringResult::getClusters) + .flatMap(Collection::stream) + .map(this::convertCluster) + .toList(); + } + + private Cluster convertCluster(de.jplag.clustering.Cluster from) { + var strength = from.getCommunityStrength(); + var avgSimilarity = from.getAverageSimilarity(); + var member = from.getMembers().stream().map(Submission::getName).toList(); + return new Cluster(avgSimilarity, strength, member); + } +} diff --git a/jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapperTest.java b/jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapperTest.java new file mode 100644 index 000000000..59d2c8b5f --- /dev/null +++ b/jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapperTest.java @@ -0,0 +1,48 @@ +package de.jplag.reporting.reportobject.mapper; + +import de.jplag.JPlagResult; +import de.jplag.Submission; +import de.jplag.clustering.Cluster; +import de.jplag.clustering.ClusteringResult; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class ClusteringResultMapperTest { + private final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper(); + + @Test + public void test() { + // given + JPlagResult resultMock = mock(JPlagResult.class); + Cluster cluster1 = createClusterWith(0.2f, 0.4f, "1", "2"); + Cluster cluster2 = createClusterWith(0.3f, 0.6f, "3", "4", "5"); + when(resultMock.getClusteringResult()).thenReturn(List.of(new ClusteringResult<>(List.of(cluster1, cluster2), 0.3f))); + + // when + var result = clusteringResultMapper.map(resultMock); + + // then + assertEquals(List.of( + new de.jplag.reporting.reportobject.model.Cluster(0.4f, 0.2f, List.of("1", "2")), + new de.jplag.reporting.reportobject.model.Cluster(0.6f, 0.3f, List.of("3", "4", "5")) + + ), result); + } + + private Cluster createClusterWith(Float communityStrength, Float averageSimilarity, String... ids) { + var submissions = Arrays.stream(ids).map(this::submissionWithId).toList(); + return new Cluster<>(submissions, communityStrength, averageSimilarity); + } + + private Submission submissionWithId(String id) { + Submission submission = mock(Submission.class); + when(submission.getName()).thenReturn(id); + return submission; + } +}