Class name filters work in a simple way

junit-team · Nov 13, 2015 · 891efa3 · 891efa3
1 parent c924f9c
commit 891efa3
Show file tree

Hide file tree

Showing 11 changed files with 143 additions and 12 deletions.
diff --git a/junit-engine-api/src/main/java/org/junit/gen5/engine/ClassFilter.java b/junit-engine-api/src/main/java/org/junit/gen5/engine/ClassFilter.java
@@ -0,0 +1,6 @@
+package org.junit.gen5.engine;
+
+public interface ClassFilter extends EngineFilter {
+
+	boolean acceptClass(Class<?> clazz);
+}
diff --git a/junit-engine-api/src/main/java/org/junit/gen5/engine/ClassNameFilter.java b/junit-engine-api/src/main/java/org/junit/gen5/engine/ClassNameFilter.java
@@ -0,0 +1,19 @@
+package org.junit.gen5.engine;
+
+import lombok.Value;
+
+@Value
+public class ClassNameFilter implements ClassFilter {
+
+	final private String regex;
+
+	@Override
+	public boolean acceptClass(Class<?> clazz) {
+		return clazz.getSimpleName().matches(regex);
+	}
+
+	@Override
+	public String getDescription() {
+		return "Filter class names with regular expression: " + regex;
+	}
+}
diff --git a/junit-engine-api/src/main/java/org/junit/gen5/engine/EngineFilter.java b/junit-engine-api/src/main/java/org/junit/gen5/engine/EngineFilter.java
@@ -0,0 +1,6 @@
+package org.junit.gen5.engine;
+
+public interface EngineFilter {
+
+	String getDescription();
+}
diff --git a/junit-engine-api/src/main/java/org/junit/gen5/engine/TestPlanSpecification.java b/junit-engine-api/src/main/java/org/junit/gen5/engine/TestPlanSpecification.java
@@ -14,7 +14,9 @@
 import static java.util.Collections.unmodifiableList;
 import static java.util.stream.Collectors.toList;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Predicate;
@@ -43,7 +45,7 @@ public static TestPlanSpecificationElement forUniqueId(String uniqueId) {
 		return new UniqueIdSpecification(uniqueId);
 	}
 
-	public static Predicate<TestDescriptor> filterByTags(String... tagNames) {
+	public static Predicate<TestDescriptor> byTags(String... tagNames) {
 		List<String> includeTags = Arrays.asList(tagNames);
 		// @formatter:off
 		return (TestDescriptor descriptor) -> descriptor.getTags().stream()
@@ -52,10 +54,14 @@ public static Predicate<TestDescriptor> filterByTags(String... tagNames) {
 		// @formatter:on
 	}
 
-	public static Predicate<TestDescriptor> filterByEngine(String engineId) {
+	public static Predicate<TestDescriptor> byEngine(String engineId) {
 		return (TestDescriptor descriptor) -> descriptor.getUniqueId().startsWith(engineId);
 	}
 
+	public static EngineFilter classNameMatches(String regex) {
+		return new ClassNameFilter(regex);
+	}
+
 	public static TestPlanSpecification build(TestPlanSpecificationElement... elements) {
 		return build(Arrays.asList(elements));
 	}
@@ -66,9 +72,13 @@ public static TestPlanSpecification build(List<TestPlanSpecificationElement> ele
 
 	private final List<TestPlanSpecificationElement> elements;
 
+	// Descriptor Filters are evaluated by the launcher itself after engines have done their discovery.
 	// Begin predicate chain with a predicate that always evaluates to true.
 	private Predicate<TestDescriptor> descriptorFilter = (TestDescriptor descriptor) -> true;
 
+	// Engine filters are handed through to all test engines to be applied during discovery
+	private List<EngineFilter> engineFilters = new ArrayList<>();
+
 	public TestPlanSpecification(List<TestPlanSpecificationElement> elements) {
 		this.elements = elements;
 	}
@@ -87,6 +97,15 @@ public void filterWith(Predicate<TestDescriptor> filter) {
 		this.descriptorFilter = this.descriptorFilter.and(filter);
 	}
 
+	public void filterWith(EngineFilter filter) {
+		Preconditions.notNull(filter, "filter must not be null");
+		this.engineFilters.add(filter);
+	}
+
+	public List<EngineFilter> getEngineFilters() {
+		return Collections.unmodifiableList(engineFilters);
+	}
+
 	public boolean acceptDescriptor(TestDescriptor testDescriptor) {
 		Preconditions.notNull(testDescriptor, "testDescriptor must not be null");
 		return this.descriptorFilter.test(testDescriptor);

diff --git a/junit-launcher/src/main/java/org/junit/gen5/launcher/Launcher.java b/junit-launcher/src/main/java/org/junit/gen5/launcher/Launcher.java
@@ -56,10 +56,12 @@ public void execute(TestPlan testPlan) {
 
 		testPlanExecutionListener.testPlanExecutionStarted(testPlan);
 		for (TestEngine testEngine : lookupAllTestEngines()) {
-			testPlanExecutionListener.testPlanExecutionStartedOnEngine(testPlan, testEngine);
+			Optional<EngineDescriptor> engineDescriptorOptional = testPlan.getEngineDescriptorFor(testEngine);
-			Optional<EngineDescriptor> engineDescriptor = testPlan.getEngineDescriptorFor(testEngine);
+			engineDescriptorOptional.ifPresent(engineDescriptor -> {
-			testEngine.execute(new EngineExecutionContext(engineDescriptor.get(), testExecutionListener));
+				testPlanExecutionListener.testPlanExecutionStartedOnEngine(testPlan, testEngine);
-			testPlanExecutionListener.testPlanExecutionFinishedOnEngine(testPlan, testEngine);
+				testEngine.execute(new EngineExecutionContext(engineDescriptor, testExecutionListener));
+				testPlanExecutionListener.testPlanExecutionFinishedOnEngine(testPlan, testEngine);
+			});
 		}
 		testPlanExecutionListener.testPlanExecutionFinished(testPlan);
 	}

diff --git a/junit-launcher/src/main/java/org/junit/gen5/launcher/TestEngineRegistry.java b/junit-launcher/src/main/java/org/junit/gen5/launcher/TestEngineRegistry.java
@@ -28,7 +28,7 @@ static Iterable<TestEngine> lookupAllTestEngines() {
 
 			// TODO LOG
 			for (TestEngine testEngine : testEngines) {
-				System.out.println(testEngine.getId());
+				System.out.println(String.format("Discovered test engine with id: '%s'", testEngine.getId()));
 			}
 
 		}

diff --git a/junit-launcher/src/main/java/org/junit/gen5/launcher/TestPlan.java b/junit-launcher/src/main/java/org/junit/gen5/launcher/TestPlan.java
@@ -99,7 +99,7 @@ public Set<TestDescriptor> getChildren() {
 	@Override
 	public void accept(Visitor visitor) {
 		visitor.visit(this, () -> {
-			throw new UnsupportedOperationException("It's not possible to remove the whole test plan");
+			//the test plan itself will never be removed
 		});
 		new HashSet<>(engineDescriptors).forEach(child -> child.accept(visitor));
 	}

diff --git a/junit4-engine/src/main/java/org/junit/gen5/engine/junit4/JUnit4TestEngine.java b/junit4-engine/src/main/java/org/junit/gen5/engine/junit4/JUnit4TestEngine.java
@@ -14,13 +14,14 @@
 import static java.util.stream.Collectors.*;
 
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import org.junit.gen5.engine.ClassFilter;
 import org.junit.gen5.engine.EngineDescriptor;
 import org.junit.gen5.engine.EngineExecutionContext;
+import org.junit.gen5.engine.EngineFilter;
 import org.junit.gen5.engine.TestDescriptor;
 import org.junit.gen5.engine.TestEngine;
 import org.junit.gen5.engine.TestPlanSpecification;
@@ -41,6 +42,27 @@ public String getId() {
 	public void discoverTests(TestPlanSpecification specification, EngineDescriptor engineDescriptor) {
 		JUnit4SpecificationResolver resolver = new JUnit4SpecificationResolver(engineDescriptor);
 		specification.accept(resolver);
+		applyEngineFilters(specification.getEngineFilters(), engineDescriptor);
+	}
+
+	// More or less copied over from JUnit5TestEngine
+	private void applyEngineFilters(List<EngineFilter> engineFilters, EngineDescriptor engineDescriptor) {
+		//Todo: Currently only works with a single ClassFilter
+		if (engineFilters.isEmpty())
+			return;
+		ClassFilter filter = (ClassFilter) engineFilters.get(0);
+
+		TestDescriptor.Visitor filteringVisitor = (descriptor, remove) -> {
+			if (descriptor instanceof DescriptionTestDescriptor) {
+				DescriptionTestDescriptor descriptionTestDescriptor = (DescriptionTestDescriptor) descriptor;
+				descriptionTestDescriptor.getTestClass().ifPresent(clazz -> {
+					if (!filter.acceptClass(clazz))
+						remove.run();
+				});
+			}
+		};
+
+		engineDescriptor.accept(filteringVisitor);
 	}
 
 	@Override

diff --git a/junit4-launcher-runner/src/main/java/org/junit/gen5/junit4runner/JUnit5.java b/junit4-launcher-runner/src/main/java/org/junit/gen5/junit4runner/JUnit5.java
@@ -25,6 +25,7 @@
 import java.util.function.Predicate;
 
 import org.junit.gen5.commons.util.StringUtils;
+import org.junit.gen5.engine.EngineFilter;
 import org.junit.gen5.engine.TestDescriptor;
 import org.junit.gen5.engine.TestPlanSpecification;
 import org.junit.gen5.engine.TestPlanSpecificationElement;
@@ -146,6 +147,29 @@ private static String getAnnotatedOnlyEngine(Class<?> testClass) {
 		return annotation.value();
 	}
 
+	/**
+	 * The <code>OnlyEngine</code> annotation specifies the engine ID to be filtered when a class
+	 * annotated with <code>@RunWith(JUnit5.class)</code> is run.
+	 */
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(ElementType.TYPE)
+	@Inherited
+	public @interface ClassNameMatches {
+
+		/**
+		 * @return regex
+		 */
+		String value();
+	}
+
+	private static String getAnnotatedClassNameMatches(Class<?> testClass) {
+		ClassNameMatches annotation = testClass.getAnnotation(ClassNameMatches.class);
+		if (annotation == null) {
+			return "";
+		}
+		return annotation.value();
+	}
+
 	private final Class<?> testClass;
 	private final TestPlanSpecification specification;
 	private final JUnit5TestTree testTree;
@@ -192,22 +216,31 @@ private TestPlanSpecification createSpecificationFromAnnotations() {
 		TestPlanSpecification plan = TestPlanSpecification.build(specs);
 		addOnlyIncludeTagsFilter(plan);
 		addOnlyIncludeEngineFilter(plan);
+		addClassNameMatches(plan);
 
 		return plan;
 	}
 
+	private void addClassNameMatches(TestPlanSpecification plan) {
+		String regex = getAnnotatedClassNameMatches(testClass).trim();
+		if (!regex.isEmpty()) {
+			EngineFilter classNameFilter = TestPlanSpecification.classNameMatches(regex);
+			plan.filterWith(classNameFilter);
+		}
+	}
+
 	private void addOnlyIncludeTagsFilter(TestPlanSpecification plan) {
 		String[] onlyIncludeTags = getAnnotatedOnlyIncludeTags(testClass);
 		if (onlyIncludeTags.length > 0) {
-			Predicate<TestDescriptor> tagNamesFilter = TestPlanSpecification.filterByTags(onlyIncludeTags);
+			Predicate<TestDescriptor> tagNamesFilter = TestPlanSpecification.byTags(onlyIncludeTags);
 			plan.filterWith(tagNamesFilter);
 		}
 	}
 
 	private void addOnlyIncludeEngineFilter(TestPlanSpecification plan) {
 		String onlyIncludeEngine = getAnnotatedOnlyEngine(testClass);
 		if (StringUtils.isNotBlank(onlyIncludeEngine)) {
-			Predicate<TestDescriptor> engineFilter = TestPlanSpecification.filterByEngine(onlyIncludeEngine);
+			Predicate<TestDescriptor> engineFilter = TestPlanSpecification.byEngine(onlyIncludeEngine);
 			plan.filterWith(engineFilter);
 		}
 	}

diff --git a/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/JUnit5TestEngine.java b/junit5-engine/src/main/java/org/junit/gen5/engine/junit5/JUnit5TestEngine.java
@@ -22,12 +22,15 @@
 import java.util.Set;
 
 import org.junit.gen5.commons.util.Preconditions;
+import org.junit.gen5.engine.ClassFilter;
 import org.junit.gen5.engine.EngineDescriptor;
 import org.junit.gen5.engine.EngineExecutionContext;
+import org.junit.gen5.engine.EngineFilter;
 import org.junit.gen5.engine.TestDescriptor;
 import org.junit.gen5.engine.TestEngine;
 import org.junit.gen5.engine.TestPlanSpecification;
 import org.junit.gen5.engine.TestPlanSpecificationElement;
+import org.junit.gen5.engine.junit5.descriptor.ClassTestDescriptor;
 import org.junit.gen5.engine.junit5.descriptor.SpecificationResolver;
 import org.junit.gen5.engine.junit5.execution.TestExecutionNode;
 import org.junit.gen5.engine.junit5.execution.TestExecutionNodeResolver;
@@ -53,6 +56,26 @@ private void resolveSpecification(TestPlanSpecification specification, EngineDes
 		for (TestPlanSpecificationElement element : specification) {
 			resolver.resolveElement(element);
 		}
+		applyEngineFilters(specification.getEngineFilters(), engineDescriptor);
+	}
+
+	private void applyEngineFilters(List<EngineFilter> engineFilters, EngineDescriptor engineDescriptor) {
+		//Todo: Currently only works with a single ClassFilter
+		if (engineFilters.isEmpty())
+			return;
+		ClassFilter filter = (ClassFilter) engineFilters.get(0);
+		TestDescriptor.Visitor filteringVisitor = new TestDescriptor.Visitor() {
+
+			@Override
+			public void visit(TestDescriptor descriptor, Runnable remove) {
+				if (descriptor instanceof ClassTestDescriptor) {
+					ClassTestDescriptor classTestDescriptor = (ClassTestDescriptor) descriptor;
+					if (!filter.acceptClass(classTestDescriptor.getTestClass()))
+						remove.run();
+				}
+			}
+		};
+		engineDescriptor.accept(filteringVisitor);
 	}
 
 	@Override

diff --git a/sample-project/src/test/java/com/example/JUnit4SamplesSuite.java b/sample-project/src/test/java/com/example/JUnit4SamplesSuite.java
@@ -22,8 +22,9 @@
 	"junit5:com.example.SampleTestCase#assertAllFailingTest()",
 	"junit5:com.example.SampleTestCase@AnInnerTestContext" })
 @Packages({ "com.example.subpackage" })
+//@ClassNameMatches(".*TestCase.")
 //@OnlyIncludeTags({ "fast" })
-//@JUnit5.OnlyEngine("junit5")
+//@OnlyEngine("junit5")
 public class JUnit4SamplesSuite {
 
 	// When you have the following method, it overrides all annotations