Add JUnit-specific metadata to open-test-reporting's HTML report (#4116)

When creating the event-based XML report, the
`OpenTestReportGeneratingListener` includes JUnit-specific metadata:
type, unique ID, and legacy reporting name. This PR implements 
open-test-reporting's `Contributor` SPI to include that data in the new
HTML report of open-test-reporting.

Moreover, it configures the build to create a single report for all test
tasks per subproject and uploads it as part of GitHub Action runs.

Author: marcphilipp

.github/actions/main-build/action.yml

@@ -16,3 +16,8 @@ runs:
       with:
         arguments: ${{ inputs.arguments }}
         encryptionKey: ${{ inputs.encryptionKey }}
+    - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+      if: ${{ always() }}
+      with:
+        name: Open Test Reports (${{ github.job }})
+        path: '**/build/reports/open-test-report.html'

.github/workflows/cross-version.yml

@@ -66,6 +66,11 @@ jobs:
             -Dscan.tag.JDK_${{ matrix.jdk.version }} \
             build \
             --configuration-cache
+      - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        if: ${{ always() }}
+        with:
+          name: Open Test Reports (${{ github.job }} ${{ matrix.jdk.version }} (${{ matrix.jdk.release || matrix.jdk.type }}))
+          path: '**/build/reports/open-test-report.html'
   openj9:
     strategy:
       fail-fast: false
@@ -102,3 +107,8 @@ jobs:
             -Dscan.tag.OpenJ9 \
             build \
             --configuration-cache
+      - uses: actions/upload-artifact@b4b15b8c7c6ac21ea08fcf65892d2ee8f75cf882 # v4
+        if: ${{ always() }}
+        with:
+          name: Open Test Reports (${{ github.job }})
+          path: '**/build/reports/open-test-report.html'

documentation/documentation.gradle.kts

@@ -6,6 +6,7 @@ import junitbuild.javadoc.ModuleSpecificJavadocFileOption
 import org.asciidoctor.gradle.base.AsciidoctorAttributeProvider
 import org.asciidoctor.gradle.jvm.AbstractAsciidoctorTask
 import org.gradle.api.tasks.PathSensitivity.RELATIVE
+import java.nio.file.Files
 
 plugins {
 	alias(libs.plugins.asciidoctorConvert)
@@ -144,23 +145,40 @@ require(externalModulesWithoutModularJavadoc.values.all { it.endsWith("/") }) {
 
 tasks {
 
+	val consoleLauncherTestReportsDir = project.layout.buildDirectory.dir("console-launcher-test-results")
+	val consoleLauncherTestEventXmlFiles =
+		files(consoleLauncherTestReportsDir.map { it.asFileTree.matching { include("junit-platform-events-*.xml") } })
+
 	val consoleLauncherTest by registering(RunConsoleLauncher::class) {
 		args.addAll("execute")
 		args.addAll("--scan-classpath")
 		args.addAll("--config=junit.platform.reporting.open.xml.enabled=true")
-		val reportsDir = project.layout.buildDirectory.dir("console-launcher-test-results")
-		outputs.dir(reportsDir)
+		outputs.dir(consoleLauncherTestReportsDir)
 		argumentProviders.add(CommandLineArgumentProvider {
 			listOf(
-				"--reports-dir=${reportsDir.get()}",
-				"--config=junit.platform.reporting.output.dir=${reportsDir.get()}"
-
+				"--reports-dir=${consoleLauncherTestReportsDir.get()}",
+				"--config=junit.platform.reporting.output.dir=${consoleLauncherTestReportsDir.get()}",
 			)
 		})
 		args.addAll("--include-classname", ".*Tests")
 		args.addAll("--include-classname", ".*Demo")
 		args.addAll("--exclude-tag", "exclude")
 		args.addAll("--exclude-tag", "timeout")
+
+		doFirst {
+			consoleLauncherTestEventXmlFiles.files.forEach {
+				Files.delete(it.toPath())
+			}
+		}
+
+		finalizedBy(generateOpenTestHtmlReport)
+	}
+
+	generateOpenTestHtmlReport {
+		mustRunAfter(consoleLauncherTest)
+		argumentProviders += CommandLineArgumentProvider {
+			consoleLauncherTestEventXmlFiles.files.map { it.absolutePath }.toList()
+		}
 	}
 
 	register<RunConsoleLauncher>("consoleLauncher") {

documentation/src/docs/asciidoc/release-notes/release-notes-5.12.0-M1.adoc

@@ -38,6 +38,9 @@ JUnit repository on GitHub.
   `--select-file` and `--select-resource`.
 * `ConsoleLauncher` now accepts multiple values for all `--select` options.
 * Add `--select-unique-id` support to ConsoleLauncher.
+* The `junit-platform-reporting` module now contributes a section containing
+  JUnit-specific metadata about each test/container to the HTML report written by
+  open-test-reporting when added to the classpath/module path.
 
 
 [[release-notes-5.12.0-M1-junit-jupiter]]

gradle/libs.versions.toml

@@ -15,7 +15,7 @@ junit4Min = "4.12"
 ktlint = "1.4.1"
 log4j = "2.24.1"
 opentest4j = "1.3.0"
-openTestReporting = "0.1.0-M2"
+openTestReporting = "0.1.0-SNAPSHOT"
 surefire = "3.5.2"
 xmlunit = "2.10.0"
 
@@ -56,8 +56,10 @@ memoryfilesystem = { module = "com.github.marschall:memoryfilesystem", version =
 mockito = { module = "org.mockito:mockito-junit-jupiter", version = "5.14.2" }
 nohttp-checkstyle = { module = "io.spring.nohttp:nohttp-checkstyle", version = "0.0.11" }
 opentest4j = { module = "org.opentest4j:opentest4j", version.ref = "opentest4j" }
+openTestReporting-cli = { module = "org.opentest4j.reporting:open-test-reporting-cli", version.ref = "openTestReporting" }
 openTestReporting-events = { module = "org.opentest4j.reporting:open-test-reporting-events", version.ref = "openTestReporting" }
-openTestReporting-tooling = { module = "org.opentest4j.reporting:open-test-reporting-tooling", version.ref = "openTestReporting" }
+openTestReporting-tooling-core = { module = "org.opentest4j.reporting:open-test-reporting-tooling-core", version.ref = "openTestReporting" }
+openTestReporting-tooling-spi = { module = "org.opentest4j.reporting:open-test-reporting-tooling-spi", version.ref = "openTestReporting" }
 picocli = { module = "info.picocli:picocli", version = "4.7.6" }
 slf4j-julBinding = { module = "org.slf4j:slf4j-jdk14", version = "2.0.16" }
 spock1 = { module = "org.spockframework:spock-core", version = "1.3-groovy-2.5" }

gradle/plugins/common/src/main/kotlin/junitbuild.testing-conventions.gradle.kts

@@ -1,14 +1,50 @@
+
 import com.gradle.develocity.agent.gradle.internal.test.PredictiveTestSelectionConfigurationInternal
 import com.gradle.develocity.agent.gradle.test.PredictiveTestSelectionMode
+import org.gradle.api.tasks.PathSensitivity.NONE
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
 import org.gradle.api.tasks.testing.logging.TestLogEvent.FAILED
 import org.gradle.internal.os.OperatingSystem
+import java.nio.file.Files
 
 plugins {
 	`java-library`
 	id("junitbuild.build-parameters")
 }
 
+var openTestReportingCli = configurations.dependencyScope("openTestReportingCli")
+var openTestReportingCliClasspath = configurations.resolvable("openTestReportingCliClasspath") {
+	extendsFrom(openTestReportingCli.get())
+}
+
+val generateOpenTestHtmlReport by tasks.registering(JavaExec::class) {
+	mustRunAfter(tasks.withType<Test>())
+	mainClass.set("org.opentest4j.reporting.cli.ReportingCli")
+	args("html-report")
+	classpath(openTestReportingCliClasspath)
+	argumentProviders += objects.newInstance(HtmlReportParameters::class).apply {
+		eventXmlFiles.from(tasks.withType<Test>().map {
+			objects.fileTree()
+				.from(it.reports.junitXml.outputLocation)
+				.include("junit-platform-events-*.xml")
+		})
+		outputLocation = layout.buildDirectory.file("reports/open-test-report.html")
+	}
+}
+
+abstract class HtmlReportParameters : CommandLineArgumentProvider {
+
+	@get:InputFiles
+	@get:PathSensitive(NONE)
+	abstract val eventXmlFiles: ConfigurableFileCollection
+
+	@get:OutputFile
+	abstract val outputLocation: RegularFileProperty
+
+	override fun asArguments() = listOf("--output", outputLocation.get().asFile.absolutePath) +
+			eventXmlFiles.map { it.absolutePath }.toList()
+}
+
 tasks.withType<Test>().configureEach {
 	useJUnitPlatform {
 		includeEngines("junit-jupiter")
@@ -79,6 +115,15 @@ tasks.withType<Test>().configureEach {
 			"-Djunit.platform.reporting.output.dir=${reports.junitXml.outputLocation.get().asFile.absolutePath}"
 		)
 	}
+
+	val reportFiles = objects.fileTree().from(reports.junitXml.outputLocation).matching { include("junit-platform-events-*.xml") }
+	doFirst {
+		reportFiles.files.forEach {
+			Files.delete(it.toPath())
+		}
+	}
+
+	finalizedBy(generateOpenTestHtmlReport)
 }
 
 dependencies {
@@ -98,4 +143,7 @@ dependencies {
 	testRuntimeOnly(dependencyFromLibs("openTestReporting-events")) {
 		because("it's required to run tests via IntelliJ which does not consumed the shadowed jar of junit-platform-reporting")
 	}
+
+	openTestReportingCli(dependencyFromLibs("openTestReporting-cli"))
+	openTestReportingCli(project(":junit-platform-reporting"))
 }

junit-platform-console-standalone/junit-platform-console-standalone.gradle.kts

@@ -17,6 +17,8 @@ dependencies {
 	shadowed(libs.apiguardian) {
 		because("downstream projects need it to avoid compiler warnings")
 	}
+
+	osgiVerification(libs.openTestReporting.tooling.spi)
 }
 
 val jupiterVersion = rootProject.version

junit-platform-console/junit-platform-console.gradle.kts

@@ -20,6 +20,7 @@ dependencies {
 
 	osgiVerification(projects.junitJupiterEngine)
 	osgiVerification(projects.junitPlatformLauncher)
+	osgiVerification(libs.openTestReporting.tooling.spi)
 }
 
 tasks {

junit-platform-reporting/junit-platform-reporting.gradle.kts

@@ -1,6 +1,7 @@
 plugins {
 	id("junitbuild.java-library-conventions")
 	id("junitbuild.shadow-conventions")
+	`java-test-fixtures`
 }
 
 description = "JUnit Platform Reporting"
@@ -10,16 +11,23 @@ dependencies {
 	api(projects.junitPlatformLauncher)
 
 	compileOnlyApi(libs.apiguardian)
+	compileOnlyApi(libs.openTestReporting.tooling.spi)
 
 	shadowed(libs.openTestReporting.events)
 
 	osgiVerification(projects.junitJupiterEngine)
 	osgiVerification(projects.junitPlatformLauncher)
+	osgiVerification(libs.openTestReporting.tooling.spi)
+
+	testFixturesApi(projects.junitJupiterApi)
 }
 
 tasks {
 	shadowJar {
-		relocate("org.opentest4j.reporting", "org.junit.platform.reporting.shadow.org.opentest4j.reporting")
+		listOf("events", "schema").forEach { name ->
+			val packageName = "org.opentest4j.reporting.${name}"
+			relocate(packageName, "org.junit.platform.reporting.shadow.${packageName}")
+		}
 		from(projectDir) {
 			include("LICENSE-open-test-reporting.md")
 			into("META-INF")

junit-platform-reporting/src/main/java/org/junit/platform/reporting/open/xml/JUnitContributor.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2015-2024 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.platform.reporting.open.xml;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.apiguardian.api.API.Status.INTERNAL;
+
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.apiguardian.api.API;
+import org.opentest4j.reporting.schema.Namespace;
+import org.opentest4j.reporting.tooling.spi.htmlreport.Contributor;
+import org.opentest4j.reporting.tooling.spi.htmlreport.KeyValuePairs;
+import org.opentest4j.reporting.tooling.spi.htmlreport.Section;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * Contributes a section containing JUnit-specific metadata for each test node
+ * to the open-test-reporting HTML report.
+ *
+ * @since 1.12
+ */
+@SuppressWarnings("exports") // we don't want to export 'org.opentest4j.reporting.tooling.spi' transitively
+@API(status = INTERNAL, since = "1.12")
+public class JUnitContributor implements Contributor {
+
+	public JUnitContributor() {
+	}
+
+	@Override
+	public List<Section> contributeSectionsForTestNode(Element testNodeElement) {
+		return findChild(testNodeElement, Namespace.REPORTING_CORE, "metadata") //
+				.map(metadata -> {
+					Map<String, String> table = new LinkedHashMap<>();
+					findChild(metadata, JUnitFactory.NAMESPACE, "type") //
+							.map(Node::getTextContent) //
+							.ifPresent(value -> table.put("Type", value));
+					findChild(metadata, JUnitFactory.NAMESPACE, "uniqueId") //
+							.map(Node::getTextContent) //
+							.ifPresent(value -> table.put("Unique ID", value));
+					findChild(metadata, JUnitFactory.NAMESPACE, "legacyReportingName") //
+							.map(Node::getTextContent) //
+							.ifPresent(value -> table.put("Legacy reporting name", value));
+					return table;
+				}) //
+				.filter(table -> !table.isEmpty()) //
+				.map(table -> singletonList(Section.builder() //
+						.title("JUnit metadata") //
+						.order(15) //
+						.addBlock(KeyValuePairs.builder().content(table).build()) //
+						.build())) //
+				.orElse(emptyList());
+	}
+
+	private static Optional<Node> findChild(Node parent, Namespace namespace, String localName) {
+		NodeList children = parent.getChildNodes();
+		for (int i = 0; i < children.getLength(); i++) {
+			Node child = children.item(i);
+			if (localName.equals(child.getLocalName()) && namespace.getUri().equals(child.getNamespaceURI())) {
+				return Optional.of(child);
+			}
+		}
+		return Optional.empty();
+	}
+}