Use real names and class names in JUnitPlatform runner

Prior to this commit, display names were used as the `name` and
`className` in Descriptions created by the JUnitPlatform runner. This
behavior had a coolness factor in that emoji and special characters
would be displayed in IDEs and test reports. More importantly, however,
it had a huge negative side effect in that such reports were not
hierarchically structured. Specifically, all test classes appeared to
be in the "default" package, which is not very useful for tooling or
analysis.

Consequently, this commit now uses real method names and class names in
Descriptions for "tests" created by the JUnitPlatform runner if the
source of the test is a Java method. This commit does not alter the
existing support for "suites" (i.e., test containers) or test sources
other than Java methods; in those cases, the display name is still used.

Issue: #372

Author: sbrannen

junit-platform-runner/src/main/java/org/junit/platform/runner/JUnitPlatformTestTree.java

@@ -15,11 +15,17 @@
 
 import java.util.HashMap;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Predicate;
 
+import org.junit.platform.commons.util.StringUtils;
+import org.junit.platform.engine.TestSource;
+import org.junit.platform.engine.support.descriptor.JavaClassSource;
+import org.junit.platform.engine.support.descriptor.JavaMethodSource;
 import org.junit.platform.launcher.TestIdentifier;
 import org.junit.platform.launcher.TestPlan;
 import org.junit.runner.Description;
@@ -73,14 +79,59 @@ private void buildDescription(TestIdentifier identifier, Description parent, Tes
 
 	private Description createJUnit4Description(TestIdentifier identifier, TestPlan testPlan) {
 		if (identifier.isTest()) {
-			return Description.createTestDescription(testPlan.getParent(identifier).orElse(identifier).getDisplayName(),
-				identifier.getDisplayName(), identifier.getUniqueId());
+			String className = getClassName(identifier, testPlan);
+			String name = getName(identifier);
+			return Description.createTestDescription(className, name, identifier.getUniqueId());
 		}
 		else {
 			return Description.createSuiteDescription(identifier.getDisplayName(), identifier.getUniqueId());
 		}
 	}
 
+	private String getName(TestIdentifier testIdentifier) {
+		Optional<TestSource> optionalSource = testIdentifier.getSource();
+		if (optionalSource.isPresent()) {
+			TestSource source = optionalSource.get();
+			if (source instanceof JavaClassSource) {
+				return ((JavaClassSource) source).getJavaClass().getName();
+			}
+			else if (source instanceof JavaMethodSource) {
+				JavaMethodSource javaMethodSource = (JavaMethodSource) source;
+				List<Class<?>> parameterTypes = javaMethodSource.getJavaMethodParameterTypes();
+				if (parameterTypes.size() == 0) {
+					return javaMethodSource.getJavaMethodName();
+				}
+				else {
+					return String.format("%s(%s)", javaMethodSource.getJavaMethodName(), StringUtils.nullSafeToString(
+						Class::getName, parameterTypes.toArray(new Class<?>[parameterTypes.size()])));
+				}
+			}
+		}
+
+		// Else fall back to display name
+		return testIdentifier.getDisplayName();
+	}
+
+	private String getClassName(TestIdentifier testIdentifier, TestPlan testPlan) {
+		Optional<TestSource> optionalSource = testIdentifier.getSource();
+		if (optionalSource.isPresent()) {
+			TestSource source = optionalSource.get();
+			if (source instanceof JavaClassSource) {
+				return ((JavaClassSource) source).getJavaClass().getName();
+			}
+			else if (source instanceof JavaMethodSource) {
+				return ((JavaMethodSource) source).getJavaClass().getName();
+			}
+		}
+
+		// Else fall back to display name of parent
+		// @formatter:off
+		return testPlan.getParent(testIdentifier)
+				.map(TestIdentifier::getDisplayName)
+				.orElse("<unrooted>");
+		// @formatter:on
+	}
+
 	Set<TestIdentifier> getTestsInSubtree(TestIdentifier ancestor) {
 		// @formatter:off
 		return plan.getDescendants(ancestor).stream()

platform-tests/src/test/java/org/junit/platform/engine/support/hierarchical/DummyTestDescriptor.java

@@ -13,6 +13,7 @@
 import static org.junit.platform.engine.support.hierarchical.Node.SkipResult.doNotSkip;
 import static org.junit.platform.engine.support.hierarchical.Node.SkipResult.skip;
 
+import org.junit.platform.engine.TestSource;
 import org.junit.platform.engine.UniqueId;
 import org.junit.platform.engine.support.descriptor.AbstractTestDescriptor;
 
@@ -26,7 +27,14 @@ public class DummyTestDescriptor extends AbstractTestDescriptor implements Node<
 	private boolean skipped;
 
 	DummyTestDescriptor(UniqueId uniqueId, String displayName, Runnable runnable) {
+		this(uniqueId, displayName, null, runnable);
+	}
+
+	DummyTestDescriptor(UniqueId uniqueId, String displayName, TestSource source, Runnable runnable) {
 		super(uniqueId, displayName);
+		if (source != null) {
+			setSource(source);
+		}
 		this.runnable = runnable;
 	}
 

platform-tests/src/test/java/org/junit/platform/engine/support/hierarchical/DummyTestEngine.java

@@ -10,10 +10,13 @@
 
 package org.junit.platform.engine.support.hierarchical;
 
+import java.lang.reflect.Method;
+
 import org.junit.platform.engine.EngineDiscoveryRequest;
 import org.junit.platform.engine.ExecutionRequest;
 import org.junit.platform.engine.TestDescriptor;
 import org.junit.platform.engine.UniqueId;
+import org.junit.platform.engine.support.descriptor.JavaMethodSource;
 
 /**
  * @since 1.0
@@ -45,6 +48,14 @@ public DummyTestDescriptor addTest(String uniqueName, Runnable runnable) {
 		return addTest(uniqueName, uniqueName, runnable);
 	}
 
+	public DummyTestDescriptor addTest(Method testMethod, Runnable runnable) {
+		UniqueId uniqueId = engineDescriptor.getUniqueId().append("test", testMethod.getName());
+		JavaMethodSource source = new JavaMethodSource(testMethod);
+		DummyTestDescriptor child = new DummyTestDescriptor(uniqueId, testMethod.getName(), source, runnable);
+		engineDescriptor.addChild(child);
+		return child;
+	}
+
 	public DummyTestDescriptor addTest(String uniqueName, String displayName, Runnable runnable) {
 		UniqueId uniqueId = engineDescriptor.getUniqueId().append("test", uniqueName);
 		DummyTestDescriptor child = new DummyTestDescriptor(uniqueId, displayName, runnable);
@@ -61,4 +72,5 @@ public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId
 	protected DummyEngineExecutionContext createExecutionContext(ExecutionRequest request) {
 		return new DummyEngineExecutionContext();
 	}
+
 }

platform-tests/src/test/java/org/junit/platform/runner/JUnitPlatformRunnerTests.java

@@ -15,6 +15,7 @@
 import static java.util.Collections.singleton;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.fail;
+import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -34,6 +35,8 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.List;
 
 import org.junit.jupiter.api.Nested;
@@ -381,6 +384,43 @@ void reportsIgnoredEventsForLeavesWhenContainerIsSkipped() throws Exception {
 
 	}
 
+	@Nested
+	class Descriptions {
+
+		@Test
+		void descriptionForJavaMethodSource() throws Exception {
+			DummyTestEngine engine = new DummyTestEngine("dummy");
+			Method failingTest = getClass().getDeclaredMethod("failingTest");
+			engine.addTest(failingTest, () -> {
+			});
+
+			JUnitPlatform platformRunner = new JUnitPlatform(TestClass.class, createLauncher(engine));
+
+			ArrayList<Description> children = platformRunner.getDescription().getChildren();
+			assertEquals(1, children.size());
+			Description engineDescription = children.get(0);
+			assertEquals("dummy", engineDescription.getDisplayName());
+
+			children = engineDescription.getChildren();
+			assertEquals(1, children.size());
+			Description testDescription = children.get(0);
+			// @formatter:off
+			assertAll(
+				() -> assertEquals(getClass().getName(), testDescription.getClassName(), "class name"),
+				() -> assertEquals("failingTest", testDescription.getMethodName(), "method name"),
+				() -> assertEquals("failingTest(" + getClass().getName() + ")", testDescription.getDisplayName(), "display name")
+			);
+			// @formatter:on
+		}
+
+		void failingTest() {
+			// not actually invoked
+		}
+
+	}
+
+	// -------------------------------------------------------------------------
+
 	private static Description suiteDescription(String uniqueId) {
 		return createSuiteDescription(uniqueId, uniqueId);
 	}