Skip to content

Commit fbfcb36

Browse files
yhkuo41yhkuo41
committed
Introduce method filter support in the ConsoleLauncher
Issue: #3107
1 parent 6dbfd46 commit fbfcb36

File tree

12 files changed

+572
-1
lines changed

12 files changed

+572
-1
lines changed

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

+4-1
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,10 @@ JUnit repository on GitHub.
4747
[[release-notes-5.12.0-M1-junit-jupiter-new-features-and-improvements]]
4848
==== New Features and Improvements
4949

50-
* ❓
50+
* New `--exclude-methodname` and `--include-methodname` options added to the
51+
`ConsoleLauncher` to include or exclude methods based on fully qualified method names
52+
without parameters. For example, `--exclude-methodname=^org\.example\..+#methodname`
53+
will exclude all methods called `methodName` under package `org.example`.
5154

5255

5356
[[release-notes-5.12.0-M1-junit-vintage]]

‎junit-platform-console/src/main/java/org/junit/platform/console/options/TestDiscoveryOptions.java

+18
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,8 @@ public class TestDiscoveryOptions {
6464
private List<String> excludedClassNamePatterns = emptyList();
6565
private List<String> includedPackages = emptyList();
6666
private List<String> excludedPackages = emptyList();
67+
private List<String> includedMethodNamePatterns = emptyList();
68+
private List<String> excludedMethodNamePatterns = emptyList();
6769
private List<String> includedEngines = emptyList();
6870
private List<String> excludedEngines = emptyList();
6971
private List<String> includedTagExpressions = emptyList();
@@ -235,6 +237,22 @@ public void setExcludedPackages(List<String> excludedPackages) {
235237
this.excludedPackages = excludedPackages;
236238
}
237239

240+
public List<String> getIncludedMethodNamePatterns() {
241+
return includedMethodNamePatterns;
242+
}
243+
244+
public void setIncludedMethodNamePatterns(List<String> includedMethodNamePatterns) {
245+
this.includedMethodNamePatterns = includedMethodNamePatterns;
246+
}
247+
248+
public List<String> getExcludedMethodNamePatterns() {
249+
return excludedMethodNamePatterns;
250+
}
251+
252+
public void setExcludedMethodNamePatterns(List<String> excludedMethodNamePatterns) {
253+
this.excludedMethodNamePatterns = excludedMethodNamePatterns;
254+
}
255+
238256
public List<String> getIncludedEngines() {
239257
return this.includedEngines;
240258
}

‎junit-platform-console/src/main/java/org/junit/platform/console/options/TestDiscoveryOptionsMixin.java

+12
Original file line numberDiff line numberDiff line change
@@ -202,6 +202,16 @@ static class FilterOptions {
202202
@Option(names = { "-exclude-package" }, arity = "1", hidden = true)
203203
private final List<String> excludePackages2 = new ArrayList<>();
204204

205+
@Option(names = {
206+
"--include-methodname" }, paramLabel = "PATTERN", arity = "1", description = "Provide a regular expression to include only methods whose fully qualified names without parameters match. " //
207+
+ "When this option is repeated, all patterns will be combined using OR semantics.")
208+
private List<String> includeMethodNamePatterns = new ArrayList<>();
209+
210+
@Option(names = {
211+
"--exclude-methodname" }, paramLabel = "PATTERN", arity = "1", description = "Provide a regular expression to exclude those methods whose fully qualified names without parameters match. " //
212+
+ "When this option is repeated, all patterns will be combined using OR semantics.")
213+
private List<String> excludeMethodNamePatterns = new ArrayList<>();
214+
205215
@Option(names = { "-t",
206216
"--include-tag" }, paramLabel = "TAG", arity = "1", description = "Provide a tag or tag expression to include only tests whose tags match. "
207217
+ //
@@ -239,6 +249,8 @@ private void applyTo(TestDiscoveryOptions result) {
239249
result.setExcludedClassNamePatterns(merge(this.excludeClassNamePatterns, this.excludeClassNamePatterns2));
240250
result.setIncludedPackages(merge(this.includePackages, this.includePackages2));
241251
result.setExcludedPackages(merge(this.excludePackages, this.excludePackages2));
252+
result.setIncludedMethodNamePatterns(new ArrayList<>(this.includeMethodNamePatterns));
253+
result.setExcludedMethodNamePatterns(new ArrayList<>(this.excludeMethodNamePatterns));
242254
result.setIncludedTagExpressions(merge(this.includedTags, this.includedTags2));
243255
result.setExcludedTagExpressions(merge(this.excludedTags, this.excludedTags2));
244256
result.setIncludedEngines(merge(this.includedEngines, this.includedEngines2));

‎junit-platform-console/src/main/java/org/junit/platform/console/tasks/DiscoveryRequestCreator.java

+10
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@
1818
import static org.junit.platform.engine.discovery.PackageNameFilter.includePackageNames;
1919
import static org.junit.platform.launcher.EngineFilter.excludeEngines;
2020
import static org.junit.platform.launcher.EngineFilter.includeEngines;
21+
import static org.junit.platform.launcher.MethodFilter.excludeMethodNamePatterns;
22+
import static org.junit.platform.launcher.MethodFilter.includeMethodNamePatterns;
2123
import static org.junit.platform.launcher.TagFilter.excludeTags;
2224
import static org.junit.platform.launcher.TagFilter.includeTags;
2325
import static org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder.request;
@@ -106,6 +108,14 @@ private void addFilters(LauncherDiscoveryRequestBuilder requestBuilder, TestDisc
106108
requestBuilder.filters(excludePackageNames(options.getExcludedPackages()));
107109
}
108110

111+
if (!options.getIncludedMethodNamePatterns().isEmpty()) {
112+
requestBuilder.filters(includeMethodNamePatterns(options.getIncludedMethodNamePatterns()));
113+
}
114+
115+
if (!options.getExcludedMethodNamePatterns().isEmpty()) {
116+
requestBuilder.filters(excludeMethodNamePatterns(options.getExcludedMethodNamePatterns()));
117+
}
118+
109119
if (!options.getIncludedTagExpressions().isEmpty()) {
110120
requestBuilder.filters(includeTags(options.getIncludedTagExpressions()));
111121
}

‎junit-platform-launcher/src/main/java/org/junit/platform/launcher/AbstractMethodFilter.java

+64
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
/*
2+
* Copyright 2015-2024 the original author or authors.
3+
*
4+
* All rights reserved. This program and the accompanying materials are
5+
* made available under the terms of the Eclipse Public License v2.0 which
6+
* accompanies this distribution and is available at
7+
*
8+
* https://www.eclipse.org/legal/epl-v20.html
9+
*/
10+
11+
package org.junit.platform.launcher;
12+
13+
import static java.util.stream.Collectors.joining;
14+
import static java.util.stream.Collectors.toList;
15+
16+
import java.util.Arrays;
17+
import java.util.List;
18+
import java.util.Optional;
19+
import java.util.regex.Pattern;
20+
21+
import org.junit.platform.commons.util.Preconditions;
22+
import org.junit.platform.commons.util.ReflectionUtils;
23+
import org.junit.platform.engine.TestDescriptor;
24+
import org.junit.platform.engine.support.descriptor.MethodSource;
25+
26+
/**
27+
* Abstract {@link MethodFilter} that servers as a superclass
28+
* for filters including or excluding fully qualified method names
29+
* without parameters based on pattern-matching.
30+
*
31+
* @since 1.12
32+
*/
33+
abstract class AbstractMethodFilter implements MethodFilter {
34+
35+
protected final List<Pattern> patterns;
36+
protected final String patternDescription;
37+
38+
AbstractMethodFilter(String... patterns) {
39+
Preconditions.notEmpty(patterns, "patterns array must not be null or empty");
40+
Preconditions.containsNoNullElements(patterns, "patterns array must not contain null elements");
41+
this.patterns = Arrays.stream(patterns).map(Pattern::compile).collect(toList());
42+
this.patternDescription = Arrays.stream(patterns).collect(joining("' OR '", "'", "'"));
43+
}
44+
45+
protected Optional<Pattern> findMatchingPattern(String methodName) {
46+
if (methodName == null) {
47+
return Optional.empty();
48+
}
49+
return this.patterns.stream().filter(pattern -> pattern.matcher(methodName).matches()).findAny();
50+
}
51+
52+
protected String getFullyQualifiedMethodNameFromDescriptor(TestDescriptor descriptor) {
53+
return descriptor.getSource() //
54+
.filter(source -> source instanceof MethodSource) //
55+
.map(methodSource -> getFullyQualifiedMethodNameWithoutParameters(((MethodSource) methodSource))) //
56+
.orElse(null);
57+
}
58+
59+
private String getFullyQualifiedMethodNameWithoutParameters(MethodSource methodSource) {
60+
String methodNameWithParentheses = ReflectionUtils.getFullyQualifiedMethodName(methodSource.getJavaClass(),
61+
methodSource.getMethodName(), (Class<?>[]) null);
62+
return methodNameWithParentheses.substring(0, methodNameWithParentheses.length() - 2);
63+
}
64+
}

‎junit-platform-launcher/src/main/java/org/junit/platform/launcher/ExcludeMethodFilter.java

+58
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
/*
2+
* Copyright 2015-2024 the original author or authors.
3+
*
4+
* All rights reserved. This program and the accompanying materials are
5+
* made available under the terms of the Eclipse Public License v2.0 which
6+
* accompanies this distribution and is available at
7+
*
8+
* https://www.eclipse.org/legal/epl-v20.html
9+
*/
10+
11+
package org.junit.platform.launcher;
12+
13+
import static org.junit.platform.engine.FilterResult.excluded;
14+
import static org.junit.platform.engine.FilterResult.included;
15+
16+
import java.util.regex.Pattern;
17+
18+
import org.junit.platform.engine.FilterResult;
19+
import org.junit.platform.engine.TestDescriptor;
20+
21+
/**
22+
* {@link MethodFilter} that matches fully qualified method names against
23+
* patterns in the form of regular expressions.
24+
*
25+
* <p>If the fully qualified name of a method matches against at least one
26+
* pattern, the class will be excluded.
27+
*
28+
* @since 1.12
29+
*/
30+
class ExcludeMethodFilter extends AbstractMethodFilter {
31+
32+
ExcludeMethodFilter(String... patterns) {
33+
super(patterns);
34+
}
35+
36+
@Override
37+
public FilterResult apply(TestDescriptor descriptor) {
38+
String methodName = getFullyQualifiedMethodNameFromDescriptor(descriptor);
39+
return findMatchingPattern(methodName) //
40+
.map(pattern -> excluded(formatExclusionReason(methodName, pattern))) //
41+
.orElseGet(() -> included(formatInclusionReason(methodName)));
42+
}
43+
44+
private String formatInclusionReason(String methodName) {
45+
return String.format("Method name [%s] does not match any excluded pattern: %s", methodName,
46+
patternDescription);
47+
}
48+
49+
private String formatExclusionReason(String methodName, Pattern pattern) {
50+
return String.format("Method name [%s] matches excluded pattern: '%s'", methodName, pattern);
51+
}
52+
53+
@Override
54+
public String toString() {
55+
return String.format("%s that excludes method names that match one of the following regular expressions: %s",
56+
getClass().getSimpleName(), patternDescription);
57+
}
58+
}

‎junit-platform-launcher/src/main/java/org/junit/platform/launcher/IncludeMethodFilter.java

+58
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
/*
2+
* Copyright 2015-2024 the original author or authors.
3+
*
4+
* All rights reserved. This program and the accompanying materials are
5+
* made available under the terms of the Eclipse Public License v2.0 which
6+
* accompanies this distribution and is available at
7+
*
8+
* https://www.eclipse.org/legal/epl-v20.html
9+
*/
10+
11+
package org.junit.platform.launcher;
12+
13+
import static org.junit.platform.engine.FilterResult.excluded;
14+
import static org.junit.platform.engine.FilterResult.included;
15+
16+
import java.util.regex.Pattern;
17+
18+
import org.junit.platform.engine.FilterResult;
19+
import org.junit.platform.engine.TestDescriptor;
20+
21+
/**
22+
* {@link MethodFilter} that matches fully qualified method names against
23+
* patterns in the form of regular expressions.
24+
*
25+
* <p>If the fully qualified name of a method matches against at least one
26+
* pattern, the method will be included.
27+
*
28+
* @since 1.12
29+
*/
30+
class IncludeMethodFilter extends AbstractMethodFilter {
31+
32+
IncludeMethodFilter(String... patterns) {
33+
super(patterns);
34+
}
35+
36+
@Override
37+
public FilterResult apply(TestDescriptor descriptor) {
38+
String methodName = getFullyQualifiedMethodNameFromDescriptor(descriptor);
39+
return findMatchingPattern(methodName) //
40+
.map(pattern -> included(formatInclusionReason(methodName, pattern))) //
41+
.orElseGet(() -> excluded(formatExclusionReason(methodName)));
42+
}
43+
44+
private String formatInclusionReason(String methodName, Pattern pattern) {
45+
return String.format("Method name [%s] matches included pattern: '%s'", methodName, pattern);
46+
}
47+
48+
private String formatExclusionReason(String methodName) {
49+
return String.format("Method name [%s] does not match any included pattern: %s", methodName,
50+
patternDescription);
51+
}
52+
53+
@Override
54+
public String toString() {
55+
return String.format("%s that includes method names that match one of the following regular expressions: %s",
56+
getClass().getSimpleName(), patternDescription);
57+
}
58+
}

‎junit-platform-launcher/src/main/java/org/junit/platform/launcher/MethodFilter.java

+107
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,107 @@
1+
/*
2+
* Copyright 2015-2024 the original author or authors.
3+
*
4+
* All rights reserved. This program and the accompanying materials are
5+
* made available under the terms of the Eclipse Public License v2.0 which
6+
* accompanies this distribution and is available at
7+
*
8+
* https://www.eclipse.org/legal/epl-v20.html
9+
*/
10+
11+
package org.junit.platform.launcher;
12+
13+
import static org.apiguardian.api.API.Status.EXPERIMENTAL;
14+
15+
import java.lang.reflect.Method;
16+
import java.util.List;
17+
18+
import org.apiguardian.api.API;
19+
20+
/**
21+
* {@link PostDiscoveryFilter} that is applied to the fully qualified
22+
* {@link Method} name without parameters.
23+
*
24+
* @since 1.12
25+
* @see #includeMethodNamePatterns(String...)
26+
* @see #excludeMethodNamePatterns(String...)
27+
*/
28+
@API(status = EXPERIMENTAL, since = "1.12")
29+
public interface MethodFilter extends PostDiscoveryFilter {
30+
31+
/**
32+
* Create a new <em>include</em> {@link MethodFilter} based on the
33+
* supplied patterns.
34+
*
35+
* <p>The patterns are combined using OR semantics, i.e. if the fully
36+
* qualified name of a method matches against at least one of the patterns,
37+
* the method will be included in the result set.
38+
*
39+
* @param patterns regular expressions to match against fully qualified
40+
* method names; never {@code null}, empty, or containing {@code null}
41+
* @see Class#getName()
42+
* @see Method#getName()
43+
* @see #includeMethodNamePatterns(List)
44+
* @see #excludeMethodNamePatterns(String...)
45+
*/
46+
static MethodFilter includeMethodNamePatterns(String... patterns) {
47+
return new IncludeMethodFilter(patterns);
48+
}
49+
50+
/**
51+
* Create a new <em>include</em> {@link MethodFilter} based on the
52+
* supplied patterns.
53+
*
54+
* <p>The patterns are combined using OR semantics, i.e. if the fully
55+
* qualified name of a method matches against at least one of the patterns,
56+
* the method will be included in the result set.
57+
*
58+
* @param patterns regular expressions to match against fully qualified
59+
* method names; never {@code null}, empty, or containing {@code null}
60+
* @see Class#getName()
61+
* @see Method#getName()
62+
* @see #includeMethodNamePatterns(String...)
63+
* @see #excludeMethodNamePatterns(String...)
64+
*/
65+
static MethodFilter includeMethodNamePatterns(List<String> patterns) {
66+
return includeMethodNamePatterns(patterns.toArray(new String[0]));
67+
}
68+
69+
/**
70+
* Create a new <em>exclude</em> {@link MethodFilter} based on the
71+
* supplied patterns.
72+
*
73+
* <p>The patterns are combined using OR semantics, i.e. if the fully
74+
* qualified name of a method matches against at least one of the patterns,
75+
* the method will be excluded from the result set.
76+
*
77+
* @param patterns regular expressions to match against fully qualified
78+
* method names; never {@code null}, empty, or containing {@code null}
79+
* @see Class#getName()
80+
* @see Method#getName()
81+
* @see #excludeMethodNamePatterns(List)
82+
* @see #includeMethodNamePatterns(String...)
83+
*/
84+
static MethodFilter excludeMethodNamePatterns(String... patterns) {
85+
return new ExcludeMethodFilter(patterns);
86+
}
87+
88+
/**
89+
* Create a new <em>exclude</em> {@link MethodFilter} based on the
90+
* supplied patterns.
91+
*
92+
* <p>The patterns are combined using OR semantics, i.e. if the fully
93+
* qualified name of a method matches against at least one of the patterns,
94+
* the method will be excluded from the result set.
95+
*
96+
* @param patterns regular expressions to match against fully qualified
97+
* method names; never {@code null}, empty, or containing {@code null}
98+
* @see Class#getName()
99+
* @see Method#getName()
100+
* @see #excludeMethodNamePatterns(String...)
101+
* @see #includeMethodNamePatterns(String...)
102+
*/
103+
static MethodFilter excludeMethodNamePatterns(List<String> patterns) {
104+
return excludeMethodNamePatterns(patterns.toArray(new String[0]));
105+
}
106+
107+
}

0 commit comments

Comments
 (0)