Refactor Continuous Testing RPC service and UI

ueberfuhr · ueberfuhr · commit 093e274a1e1a · 2024-09-19T07:12:35.000+02:00
- merge observers for test state and results - replace direct rendering of results and state by custom API object (DTO) - optimize size and structure of JSON message resolves #43067
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestClassResult.java b/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestClassResult.java
@@ -3,31 +3,39 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class TestClassResult implements Comparable<TestClassResult> {
+import io.quarkus.dev.testing.results.TestClassResultInterface;
+import io.quarkus.dev.testing.results.TestResultInterface;
+
+public class TestClassResult implements TestClassResultInterface {
     final String className;
     final List<TestResult> passing;
     final List<TestResult> failing;
     final List<TestResult> skipped;
     final long latestRunId;
     final long time;
 
-    public TestClassResult(String className, List<TestResult> passing, List<TestResult> failing, List<TestResult> skipped,
+    public TestClassResult(
+            String className,
+            List<TestResult> passing,
+            List<TestResult> failing,
+            List<TestResult> skipped,
             long time) {
         this.className = className;
         this.passing = passing;
         this.failing = failing;
         this.skipped = skipped;
         this.time = time;
         long runId = 0;
-        for (TestResult i : passing) {
-            runId = Math.max(i.runId, runId);
+        for (TestResultInterface i : passing) {
+            runId = Math.max(i.getRunId(), runId);
         }
-        for (TestResult i : failing) {
-            runId = Math.max(i.runId, runId);
+        for (TestResultInterface i : failing) {
+            runId = Math.max(i.getRunId(), runId);
         }
         latestRunId = runId;
     }
 
+    @Override
     public String getClassName() {
         return className;
     }
@@ -53,15 +61,12 @@ public long getTime() {
     }
 
     @Override
-    public int compareTo(TestClassResult o) {
-        return className.compareTo(o.className);
-    }
-
     public List<TestResult> getResults() {
         List<TestResult> ret = new ArrayList<>();
         ret.addAll(passing);
         ret.addAll(failing);
         ret.addAll(skipped);
         return ret;
     }
+
 }
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestResult.java b/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestResult.java
@@ -7,7 +7,9 @@
 import org.junit.platform.engine.TestExecutionResult;
 import org.junit.platform.engine.UniqueId;
 
-public class TestResult {
+import io.quarkus.dev.testing.results.TestResultInterface;
+
+public class TestResult implements TestResultInterface {
 
     final String displayName;
     final String testClass;
@@ -49,18 +51,22 @@ public TestExecutionResult getTestExecutionResult() {
         return testExecutionResult;
     }
 
+    @Override
     public List<String> getLogOutput() {
         return logOutput;
     }
 
+    @Override
     public String getDisplayName() {
         return displayName;
     }
 
+    @Override
     public String getTestClass() {
         return testClass;
     }
 
+    @Override
     public List<String> getTags() {
         return tags;
     }
@@ -69,23 +75,42 @@ public UniqueId getUniqueId() {
         return uniqueId;
     }
 
+    @Override
     public boolean isTest() {
         return test;
     }
 
+    @Override
+    public String getId() {
+        return uniqueId.toString();
+    }
+
+    @Override
     public long getRunId() {
         return runId;
     }
 
+    @Override
     public long getTime() {
         return time;
     }
 
+    @Override
     public List<Throwable> getProblems() {
         return problems;
     }
 
+    @Override
     public boolean isReportable() {
         return reportable;
     }
+
+    @Override
+    public State getState() {
+        return switch (testExecutionResult.getStatus()) {
+            case FAILED -> State.FAILED;
+            case ABORTED -> State.SKIPPED;
+            case SUCCESSFUL -> State.PASSED;
+        };
+    }
 }
diff --git a/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestRunResults.java b/core/deployment/src/main/java/io/quarkus/deployment/dev/testing/TestRunResults.java
@@ -7,8 +7,10 @@
 import java.util.Map;
 
 import io.quarkus.deployment.dev.ClassScanResult;
+import io.quarkus.dev.testing.results.TestResultInterface;
+import io.quarkus.dev.testing.results.TestRunResultsInterface;
 
-public class TestRunResults {
+public class TestRunResults implements TestRunResultsInterface {
 
     /**
      * The run id
@@ -28,7 +30,7 @@ public class TestRunResults {
     private final long started;
     private final long completed;
 
-    private final Map<String, TestClassResult> results;
+    private final Map<String, ? extends TestClassResult> results;
     private final Map<String, TestClassResult> currentFailing = new HashMap<>();
     private final Map<String, TestClassResult> historicFailing = new HashMap<>();
     private final Map<String, TestClassResult> currentPassing = new HashMap<>();
@@ -58,9 +60,9 @@ public TestRunResults(long id, ClassScanResult trigger, boolean full, long start
         long currentFailedCount = 0;
         long currentSkippedCount = 0;
         for (Map.Entry<String, TestClassResult> i : results.entrySet()) {
-            passedCount += i.getValue().getPassing().stream().filter(TestResult::isTest).count();
-            failedCount += i.getValue().getFailing().stream().filter(TestResult::isTest).count();
-            skippedCount += i.getValue().getSkipped().stream().filter(TestResult::isTest).count();
+            passedCount += i.getValue().getPassing().stream().filter(TestResultInterface::isTest).count();
+            failedCount += i.getValue().getFailing().stream().filter(TestResultInterface::isTest).count();
+            skippedCount += i.getValue().getSkipped().stream().filter(TestResultInterface::isTest).count();
             currentPassedCount += i.getValue().getPassing().stream().filter(s -> s.isTest() && s.getRunId() == id).count();
             currentFailedCount += i.getValue().getFailing().stream().filter(s -> s.isTest() && s.getRunId() == id).count();
             currentSkippedCount += i.getValue().getSkipped().stream().filter(s -> s.isTest() && s.getRunId() == id).count();
@@ -98,6 +100,7 @@ public TestRunResults(long id, ClassScanResult trigger, boolean full, long start
         this.currentSkippedCount = currentSkippedCount;
     }
 
+    @Override
     public long getId() {
         return id;
     }
@@ -110,6 +113,7 @@ public boolean isFull() {
         return full;
     }
 
+    @Override
     public Map<String, TestClassResult> getResults() {
         return Collections.unmodifiableMap(results);
     }
@@ -130,14 +134,17 @@ public Map<String, TestClassResult> getHistoricPassing() {
         return historicPassing;
     }
 
+    @Override
     public long getStartedTime() {
         return started;
     }
 
+    @Override
     public long getCompletedTime() {
         return completed;
     }
 
+    @Override
     public long getTotalTime() {
         return completed - started;
     }
@@ -154,34 +161,42 @@ public List<TestClassResult> getSkipped() {
         return skipped;
     }
 
+    @Override
     public long getPassedCount() {
         return passedCount;
     }
 
+    @Override
     public long getFailedCount() {
         return failedCount;
     }
 
+    @Override
     public long getSkippedCount() {
         return skippedCount;
     }
 
+    @Override
     public long getCurrentPassedCount() {
         return currentPassedCount;
     }
 
+    @Override
     public long getCurrentFailedCount() {
         return currentFailedCount;
     }
 
+    @Override
     public long getCurrentSkippedCount() {
         return currentSkippedCount;
     }
 
+    @Override
     public long getTotalCount() {
         return getPassedCount() + getFailedCount() + getSkippedCount();
     }
 
+    @Override
     public long getCurrentTotalCount() {
         return getCurrentPassedCount() + getCurrentFailedCount() + getCurrentSkippedCount();
     }
diff --git a/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestClassResultInterface.java b/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestClassResultInterface.java
@@ -0,0 +1,16 @@
+package io.quarkus.dev.testing.results;
+
+import java.util.List;
+
+public interface TestClassResultInterface extends Comparable<TestClassResultInterface> {
+
+    String getClassName();
+
+    List<? extends TestResultInterface> getResults();
+
+    @Override
+    default int compareTo(TestClassResultInterface o) {
+        return getClassName().compareTo(o.getClassName());
+    }
+
+}
diff --git a/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestResultInterface.java b/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestResultInterface.java
@@ -0,0 +1,34 @@
+package io.quarkus.dev.testing.results;
+
+import java.util.List;
+
+public interface TestResultInterface {
+    List<String> getLogOutput();
+
+    String getDisplayName();
+
+    String getTestClass();
+
+    List<String> getTags();
+
+    boolean isTest();
+
+    String getId();
+
+    long getRunId();
+
+    long getTime();
+
+    List<Throwable> getProblems();
+
+    boolean isReportable();
+
+    State getState();
+
+    enum State {
+        PASSED,
+        FAILED,
+        SKIPPED
+    }
+
+}
diff --git a/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestRunResultsInterface.java b/core/devmode-spi/src/main/java/io/quarkus/dev/testing/results/TestRunResultsInterface.java
@@ -0,0 +1,31 @@
+package io.quarkus.dev.testing.results;
+
+import java.util.Map;
+
+public interface TestRunResultsInterface {
+    long getId();
+
+    Map<String, ? extends TestClassResultInterface> getResults();
+
+    long getStartedTime();
+
+    long getCompletedTime();
+
+    long getTotalTime();
+
+    long getPassedCount();
+
+    long getFailedCount();
+
+    long getSkippedCount();
+
+    long getCurrentPassedCount();
+
+    long getCurrentFailedCount();
+
+    long getCurrentSkippedCount();
+
+    long getTotalCount();
+
+    long getCurrentTotalCount();
+}
diff --git a/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/menu/ContinuousTestingProcessor.java b/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/menu/ContinuousTestingProcessor.java
@@ -16,6 +16,7 @@
 import io.quarkus.deployment.dev.testing.TestRunResults;
 import io.quarkus.deployment.dev.testing.TestSupport;
 import io.quarkus.dev.spi.DevModeType;
+import io.quarkus.dev.testing.results.TestRunResultsInterface;
 import io.quarkus.devui.deployment.InternalPageBuildItem;
 import io.quarkus.devui.runtime.continuoustesting.ContinuousTestingJsonRPCService;
 import io.quarkus.devui.runtime.continuoustesting.ContinuousTestingRecorder;
@@ -237,7 +238,7 @@ private void registerGetStatusMethod(LaunchModeBuildItem launchModeBuildItem, Bu
     }
 
     private void registerGetResultsMethod(LaunchModeBuildItem launchModeBuildItem, BuildTimeActionBuildItem actions) {
-        actions.addAction("getResults", ignored -> {
+        actions.<TestRunResultsInterface> addAction("getResults", ignored -> {
             try {
                 Optional<TestSupport> ts = TestSupport.instance();
                 if (testsDisabled(launchModeBuildItem, ts)) {
diff --git a/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js b/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/devui/runtime/continuoustesting/ContinuousTestingJsonRPCService.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/devui/runtime/continuoustesting/ContinuousTestingJsonRPCService.java
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/devui/runtime/continuoustesting/ContinuousTestingJsonRPCState.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/devui/runtime/continuoustesting/ContinuousTestingJsonRPCState.java

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,9 @@`
`7`	`7`	`import org.junit.platform.engine.TestExecutionResult;`
`8`	`8`	`import org.junit.platform.engine.UniqueId;`
`9`	`9`
`10`		`-public class TestResult {`
	`10`	`+import io.quarkus.dev.testing.results.TestResultInterface;`
	`11`	`+`
	`12`	`+public class TestResult implements TestResultInterface {`
`11`	`13`
`12`	`14`	`final String displayName;`
`13`	`15`	`final String testClass;`
`@@ -49,18 +51,22 @@ public TestExecutionResult getTestExecutionResult() {`
`49`	`51`	`return testExecutionResult;`
`50`	`52`	`}`
`51`	`53`
	`54`	`+ @Override`
`52`	`55`	`public List<String> getLogOutput() {`
`53`	`56`	`return logOutput;`
`54`	`57`	`}`
`55`	`58`
	`59`	`+ @Override`
`56`	`60`	`public String getDisplayName() {`
`57`	`61`	`return displayName;`
`58`	`62`	`}`
`59`	`63`
	`64`	`+ @Override`
`60`	`65`	`public String getTestClass() {`
`61`	`66`	`return testClass;`
`62`	`67`	`}`
`63`	`68`
	`69`	`+ @Override`
`64`	`70`	`public List<String> getTags() {`
`65`	`71`	`return tags;`
`66`	`72`	`}`
`@@ -69,23 +75,42 @@ public UniqueId getUniqueId() {`
`69`	`75`	`return uniqueId;`
`70`	`76`	`}`
`71`	`77`
	`78`	`+ @Override`
`72`	`79`	`public boolean isTest() {`
`73`	`80`	`return test;`
`74`	`81`	`}`
`75`	`82`
	`83`	`+ @Override`
	`84`	`+ public String getId() {`
	`85`	`+ return uniqueId.toString();`
	`86`	`+ }`
	`87`	`+`
	`88`	`+ @Override`
`76`	`89`	`public long getRunId() {`
`77`	`90`	`return runId;`
`78`	`91`	`}`
`79`	`92`
	`93`	`+ @Override`
`80`	`94`	`public long getTime() {`
`81`	`95`	`return time;`
`82`	`96`	`}`
`83`	`97`
	`98`	`+ @Override`
`84`	`99`	`public List<Throwable> getProblems() {`
`85`	`100`	`return problems;`
`86`	`101`	`}`
`87`	`102`
	`103`	`+ @Override`
`88`	`104`	`public boolean isReportable() {`
`89`	`105`	`return reportable;`
`90`	`106`	`}`
	`107`	`+`
	`108`	`+ @Override`
	`109`	`+ public State getState() {`
	`110`	`+ return switch (testExecutionResult.getStatus()) {`
	`111`	`+ case FAILED -> State.FAILED;`
	`112`	`+ case ABORTED -> State.SKIPPED;`
	`113`	`+ case SUCCESSFUL -> State.PASSED;`
	`114`	`+ };`
	`115`	`+ }`
`91`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,10 @@`
`7`	`7`	`import java.util.Map;`
`8`	`8`
`9`	`9`	`import io.quarkus.deployment.dev.ClassScanResult;`
	`10`	`+import io.quarkus.dev.testing.results.TestResultInterface;`
	`11`	`+import io.quarkus.dev.testing.results.TestRunResultsInterface;`
`10`	`12`
`11`		`-public class TestRunResults {`
	`13`	`+public class TestRunResults implements TestRunResultsInterface {`
`12`	`14`
`13`	`15`	`/**`
`14`	`16`	`* The run id`
`@@ -28,7 +30,7 @@ public class TestRunResults {`
`28`	`30`	`private final long started;`
`29`	`31`	`private final long completed;`
`30`	`32`
`31`		`- private final Map<String, TestClassResult> results;`
	`33`	`+ private final Map<String, ? extends TestClassResult> results;`
`32`	`34`	`private final Map<String, TestClassResult> currentFailing = new HashMap<>();`
`33`	`35`	`private final Map<String, TestClassResult> historicFailing = new HashMap<>();`
`34`	`36`	`private final Map<String, TestClassResult> currentPassing = new HashMap<>();`
`@@ -58,9 +60,9 @@ public TestRunResults(long id, ClassScanResult trigger, boolean full, long start`
`58`	`60`	`long currentFailedCount = 0;`
`59`	`61`	`long currentSkippedCount = 0;`
`60`	`62`	`for (Map.Entry<String, TestClassResult> i : results.entrySet()) {`
`61`		`- passedCount += i.getValue().getPassing().stream().filter(TestResult::isTest).count();`
`62`		`- failedCount += i.getValue().getFailing().stream().filter(TestResult::isTest).count();`
`63`		`- skippedCount += i.getValue().getSkipped().stream().filter(TestResult::isTest).count();`
	`63`	`+ passedCount += i.getValue().getPassing().stream().filter(TestResultInterface::isTest).count();`
	`64`	`+ failedCount += i.getValue().getFailing().stream().filter(TestResultInterface::isTest).count();`
	`65`	`+ skippedCount += i.getValue().getSkipped().stream().filter(TestResultInterface::isTest).count();`
`64`	`66`	`currentPassedCount += i.getValue().getPassing().stream().filter(s -> s.isTest() && s.getRunId() == id).count();`
`65`	`67`	`currentFailedCount += i.getValue().getFailing().stream().filter(s -> s.isTest() && s.getRunId() == id).count();`
`66`	`68`	`currentSkippedCount += i.getValue().getSkipped().stream().filter(s -> s.isTest() && s.getRunId() == id).count();`
`@@ -98,6 +100,7 @@ public TestRunResults(long id, ClassScanResult trigger, boolean full, long start`
`98`	`100`	`this.currentSkippedCount = currentSkippedCount;`
`99`	`101`	`}`
`100`	`102`
	`103`	`+ @Override`
`101`	`104`	`public long getId() {`
`102`	`105`	`return id;`
`103`	`106`	`}`
`@@ -110,6 +113,7 @@ public boolean isFull() {`
`110`	`113`	`return full;`
`111`	`114`	`}`
`112`	`115`
	`116`	`+ @Override`
`113`	`117`	`public Map<String, TestClassResult> getResults() {`
`114`	`118`	`return Collections.unmodifiableMap(results);`
`115`	`119`	`}`
`@@ -130,14 +134,17 @@ public Map<String, TestClassResult> getHistoricPassing() {`
`130`	`134`	`return historicPassing;`
`131`	`135`	`}`
`132`	`136`
	`137`	`+ @Override`
`133`	`138`	`public long getStartedTime() {`
`134`	`139`	`return started;`
`135`	`140`	`}`
`136`	`141`
	`142`	`+ @Override`
`137`	`143`	`public long getCompletedTime() {`
`138`	`144`	`return completed;`
`139`	`145`	`}`
`140`	`146`
	`147`	`+ @Override`
`141`	`148`	`public long getTotalTime() {`
`142`	`149`	`return completed - started;`
`143`	`150`	`}`
`@@ -154,34 +161,42 @@ public List<TestClassResult> getSkipped() {`
`154`	`161`	`return skipped;`
`155`	`162`	`}`
`156`	`163`
	`164`	`+ @Override`
`157`	`165`	`public long getPassedCount() {`
`158`	`166`	`return passedCount;`
`159`	`167`	`}`
`160`	`168`
	`169`	`+ @Override`
`161`	`170`	`public long getFailedCount() {`
`162`	`171`	`return failedCount;`
`163`	`172`	`}`
`164`	`173`
	`174`	`+ @Override`
`165`	`175`	`public long getSkippedCount() {`
`166`	`176`	`return skippedCount;`
`167`	`177`	`}`
`168`	`178`
	`179`	`+ @Override`
`169`	`180`	`public long getCurrentPassedCount() {`
`170`	`181`	`return currentPassedCount;`
`171`	`182`	`}`
`172`	`183`
	`184`	`+ @Override`
`173`	`185`	`public long getCurrentFailedCount() {`
`174`	`186`	`return currentFailedCount;`
`175`	`187`	`}`
`176`	`188`
	`189`	`+ @Override`
`177`	`190`	`public long getCurrentSkippedCount() {`
`178`	`191`	`return currentSkippedCount;`
`179`	`192`	`}`
`180`	`193`
	`194`	`+ @Override`
`181`	`195`	`public long getTotalCount() {`
`182`	`196`	`return getPassedCount() + getFailedCount() + getSkippedCount();`
`183`	`197`	`}`
`184`	`198`
	`199`	`+ @Override`
`185`	`200`	`public long getCurrentTotalCount() {`
`186`	`201`	`return getCurrentPassedCount() + getCurrentFailedCount() + getCurrentSkippedCount();`
`187`	`202`	`}`