Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Introduce @EnabledIf support for JUnit Jupiter

Browse Source 
This commit picks up where SPR-14614 left off by introducing a new
@EnabledIf annotation to serve as a logical companion to @DisabledIf.

In addition, this commit extracts common logic from DisabledIfCondition
into a new AbstractExpressionEvaluatingCondition base class which the
new EnabledIfCondition also extends.

An @EnabledOnMac annotation is also included in the Javadoc as well as
in the test suite to demonstrate support for custom composed annotations.

Issue: SPR-14644
This commit is contained in:
Sam Brannen
2016-08-31 16:11:58 +02:00
parent 1a30252fc9
commit 634d1c03a3
9 changed files with 563 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
spring-test/src/main/java/org/springframework/test/context/junit/jupiter/AbstractExpressionEvaluatingCondition.java Normal file
View File

@@ -0,0 +1,167 @@
/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.context.junit.jupiter;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.util.Optional;
import java.util.function.Function;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.jupiter.api.extension.ConditionEvaluationResult;
import org.junit.jupiter.api.extension.ContainerExecutionCondition;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestExecutionCondition;
import org.springframework.beans.factory.config.BeanExpressionContext;
import org.springframework.beans.factory.config.BeanExpressionResolver;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* Abstract base class for implementations of {@link ContainerExecutionCondition}
* and {@link TestExecutionCondition} that evaluate expressions configured via
* annotations to determine if a container or test is enabled.
*
* <p>Expressions can be any of the following.
*
* <ul>
* <li>Spring Expression Language (SpEL) expression &mdash; for example:
* <pre style="code">#{systemProperties['os.name'].toLowerCase().contains('mac')}</pre>
* <li>Placeholder for a property available in the Spring
* {@link org.springframework.core.env.Environment Environment} &mdash; for example:
* <pre style="code">${smoke.tests.enabled}</pre>
* <li>Text literal &mdash; for example:
* <pre style="code">true</pre>
* </ul>
*
* @author Sam Brannen
* @author Tadaya Tsuyukubo
* @since 5.0
* @see EnabledIf
* @see DisabledIf
*/
abstract class AbstractExpressionEvaluatingCondition implements ContainerExecutionCondition, TestExecutionCondition {
private static final Log logger = LogFactory.getLog(AbstractExpressionEvaluatingCondition.class);
/**
* Evaluate the expression configured via the supplied annotation type on
* the {@link AnnotatedElement} for the supplied {@link ExtensionContext}.
*
* @param annotationType the type of annotation to process
* @param expressionExtractor a function that extracts the expression from
* the annotation
* @param reasonExtractor a function that extracts the reason from the
* annotation
* @param enabledOnTrue indicates whether the returned {@code ConditionEvaluationResult}
* should be {@link ConditionEvaluationResult#enabled enabled} if the expression
* evaluates to {@code true}
* @param context the {@code ExtensionContext}
* @return {@link ConditionEvaluationResult#enabled enabled} if the container
* or test should be enabled; otherwise {@link ConditionEvaluationResult#disabled disabled}
*/
protected <A extends Annotation> ConditionEvaluationResult evaluateAnnotation(Class<A> annotationType,
Function<A, String> expressionExtractor, Function<A, String> reasonExtractor, boolean enabledOnTrue,
ExtensionContext context) {
AnnotatedElement element = context.getElement().get();
Optional<A> annotation = findMergedAnnotation(element, annotationType);
if (!annotation.isPresent()) {
String reason = String.format("%s is enabled since @%s is not present", element,
annotationType.getSimpleName());
if (logger.isDebugEnabled()) {
logger.debug(reason);
}
return ConditionEvaluationResult.enabled(reason);
}
// @formatter:off
String expression = annotation.map(expressionExtractor).map(String::trim).filter(StringUtils::hasLength)
.orElseThrow(() -> new IllegalStateException(String.format(
"The expression in @%s on [%s] must not be blank", annotationType.getSimpleName(), element)));
// @formatter:on
boolean result = evaluateExpression(expression, annotationType, context);
if (result) {
String adjective = (enabledOnTrue ? "enabled" : "disabled");
String reason = annotation.map(reasonExtractor).filter(StringUtils::hasText).orElseGet(
() -> String.format("%s is %s because @%s(\"%s\") evaluated to true", element, adjective,
annotationType.getSimpleName(), expression));
if (logger.isInfoEnabled()) {
logger.info(reason);
}
return (enabledOnTrue ? ConditionEvaluationResult.enabled(reason)
: ConditionEvaluationResult.disabled(reason));
}
else {
String adjective = (enabledOnTrue ? "disabled" : "enabled");
String reason = String.format("%s is %s because @%s(\"%s\") did not evaluate to true",
element, adjective, annotationType.getSimpleName(), expression);
if (logger.isDebugEnabled()) {
logger.debug(reason);
}
return (enabledOnTrue ? ConditionEvaluationResult.disabled(reason)
: ConditionEvaluationResult.enabled(reason));
}
}
private <A extends Annotation> boolean evaluateExpression(String expression, Class<A> annotationType,
ExtensionContext extensionContext) {
ApplicationContext applicationContext = SpringExtension.getApplicationContext(extensionContext);
if (!(applicationContext instanceof ConfigurableApplicationContext)) {
if (logger.isWarnEnabled()) {
String contextType = (applicationContext != null ? applicationContext.getClass().getName() : "null");
logger.warn(String.format("@%s(\"%s\") could not be evaluated on [%s] since the test " +
"ApplicationContext [%s] is not a ConfigurableApplicationContext",
annotationType.getSimpleName(), expression, extensionContext.getElement(), contextType));
}
return false;
}
ConfigurableBeanFactory configurableBeanFactory = ((ConfigurableApplicationContext) applicationContext).getBeanFactory();
BeanExpressionResolver expressionResolver = configurableBeanFactory.getBeanExpressionResolver();
BeanExpressionContext beanExpressionContext = new BeanExpressionContext(configurableBeanFactory, null);
Object result = expressionResolver.evaluate(configurableBeanFactory.resolveEmbeddedValue(expression),
beanExpressionContext);
Assert.state((result instanceof Boolean || result instanceof String),
() -> String.format("@%s(\"%s\") must evaluate to a String or a Boolean, not %s",
annotationType.getSimpleName(), expression, (result != null ? result.getClass().getName() : "null")));
return (result instanceof Boolean && ((Boolean) result).booleanValue())
|| (result instanceof String && Boolean.parseBoolean((String) result));
}
private static <A extends Annotation> Optional<A> findMergedAnnotation(AnnotatedElement element,
Class<A> annotationType) {
return Optional.ofNullable(AnnotatedElementUtils.findMergedAnnotation(element, annotationType));
}
}

1
spring-test/src/main/java/org/springframework/test/context/junit/jupiter/DisabledIf.java
View File

@@ -54,6 +54,7 @@ import org.springframework.core.annotation.AliasFor;
* @author Tadaya Tsuyukubo
* @since 5.0
* @see SpringExtension
* @see EnabledIf
* @see org.junit.jupiter.api.Disabled
*/
@Target({ ElementType.TYPE, ElementType.METHOD })

92
spring-test/src/main/java/org/springframework/test/context/junit/jupiter/DisabledIfCondition.java
View File

@@ -16,13 +16,6 @@
package org.springframework.test.context.junit.jupiter;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.util.Optional;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.jupiter.api.extension.ConditionEvaluationResult;
import org.junit.jupiter.api.extension.ContainerExecutionCondition;
import org.junit.jupiter.api.extension.ContainerExtensionContext;
@@ -30,34 +23,24 @@ import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestExecutionCondition;
import org.junit.jupiter.api.extension.TestExtensionContext;
import org.springframework.beans.factory.config.BeanExpressionContext;
import org.springframework.beans.factory.config.BeanExpressionResolver;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* {@code DisabledIfCondition} is a composite {@link ContainerExecutionCondition}
* and {@link TestExecutionCondition} that supports the {@link DisabledIf @DisabledIf}
* annotation when using the <em>Spring TestContext Framework</em> in conjunction
* with JUnit 5's <em>Jupiter</em> programming model.
*
* <p>Any attempt to use {@code DisabledIfCondition} without the presence of
* {@link DisabledIf @DisabledIf} will result in an {@link IllegalStateException}.
* <p>Any attempt to use the {@code DisabledIfCondition} without the presence of
* {@link DisabledIf @DisabledIf} will result in an <em>enabled</em>
* {@link ConditionEvaluationResult}.
*
* @author Sam Brannen
* @author Tadaya Tsuyukubo
* @since 5.0
* @see org.springframework.test.context.junit.jupiter.DisabledIf
* @see org.springframework.test.context.junit.jupiter.SpringExtension
* @see DisabledIf
* @see EnabledIf
* @see SpringExtension
*/
public class DisabledIfCondition implements ContainerExecutionCondition, TestExecutionCondition {
private static final Log logger = LogFactory.getLog(DisabledIfCondition.class);
public class DisabledIfCondition extends AbstractExpressionEvaluatingCondition {
/**
* Containers are disabled if {@code @DisabledIf} is present on the test class
@@ -77,65 +60,8 @@ public class DisabledIfCondition implements ContainerExecutionCondition, TestExe
return evaluateDisabledIf(context);
}
private ConditionEvaluationResult evaluateDisabledIf(ExtensionContext extensionContext) {
AnnotatedElement element = extensionContext.getElement().get();
Optional<DisabledIf> disabledIf = findMergedAnnotation(element, DisabledIf.class);
Assert.state(disabledIf.isPresent(), () -> "@DisabledIf must be present on " + element);
// @formatter:off
String expression = disabledIf.map(DisabledIf::expression).map(String::trim).filter(StringUtils::hasLength)
.orElseThrow(() -> new IllegalStateException(String.format(
"The expression in @DisabledIf on [%s] must not be blank", element)));
// @formatter:on
if (isDisabled(expression, extensionContext)) {
String reason = disabledIf.map(DisabledIf::reason).filter(StringUtils::hasText).orElseGet(
() -> String.format("%s is disabled because @DisabledIf(\"%s\") evaluated to true", element,
expression));
logger.info(reason);
return ConditionEvaluationResult.disabled(reason);
}
else {
String reason = String.format("%s is enabled because @DisabledIf(\"%s\") did not evaluate to true",
element, expression);
logger.debug(reason);
return ConditionEvaluationResult.enabled(reason);
}
}
private boolean isDisabled(String expression, ExtensionContext extensionContext) {
ApplicationContext applicationContext = SpringExtension.getApplicationContext(extensionContext);
if (!(applicationContext instanceof ConfigurableApplicationContext)) {
if (logger.isWarnEnabled()) {
String contextType = (applicationContext != null ? applicationContext.getClass().getName() : "null");
logger.warn(String.format("@DisabledIf(\"%s\") could not be evaluated on [%s] since the test " +
"ApplicationContext [%s] is not a ConfigurableApplicationContext",
expression, extensionContext.getElement(), contextType));
}
return false;
}
ConfigurableBeanFactory configurableBeanFactory = ((ConfigurableApplicationContext) applicationContext).getBeanFactory();
BeanExpressionResolver expressionResolver = configurableBeanFactory.getBeanExpressionResolver();
BeanExpressionContext beanExpressionContext = new BeanExpressionContext(configurableBeanFactory, null);
Object result = expressionResolver.evaluate(configurableBeanFactory.resolveEmbeddedValue(expression),
beanExpressionContext);
Assert.state((result instanceof Boolean || result instanceof String), () ->
String.format("@DisabledIf(\"%s\") must evaluate to a String or a Boolean, not %s", expression,
(result != null ? result.getClass().getName() : "null")));
boolean disabled = (result instanceof Boolean && ((Boolean) result).booleanValue()) ||
(result instanceof String && Boolean.parseBoolean((String) result));
return disabled;
}
private static <A extends Annotation> Optional<A> findMergedAnnotation(AnnotatedElement element,
Class<A> annotationType) {
return Optional.ofNullable(AnnotatedElementUtils.findMergedAnnotation(element, annotationType));
private ConditionEvaluationResult evaluateDisabledIf(ExtensionContext context) {
return evaluateAnnotation(DisabledIf.class, DisabledIf::expression, DisabledIf::reason, false, context);
}
}

111
spring-test/src/main/java/org/springframework/test/context/junit/jupiter/EnabledIf.java Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.context.junit.jupiter;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.core.annotation.AliasFor;
/**
* {@code @EnabledIf} is used to signal that the annotated test class or test
* method is <em>enabled</em> and should be executed if the supplied
* {@link #expression} evaluates to {@code true}.
*
* <p>When applied at the class level, all test methods within that class
* are automatically enabled by default as well.
*
* <p>For basic examples, see the Javadoc for {@link #expression}.
*
* <p>This annotation may be used as a <em>meta-annotation</em> to create
* custom <em>composed annotations</em>. For example, a custom
* {@code @EnabledOnMac} annotation can be created as follows.
*
* <pre style="code">
* {@literal @}Target({ ElementType.TYPE, ElementType.METHOD })
* {@literal @}Retention(RetentionPolicy.RUNTIME)
* {@literal @}EnabledIf(
* expression = "#{systemProperties['os.name'].toLowerCase().contains('mac')}",
* reason = "Enabled on Mac OS"
* )
* public {@literal @}interface EnabledOnMac {}
* </pre>
*
* @author Sam Brannen
* @since 5.0
* @see SpringExtension
* @see DisabledIf
* @see org.junit.jupiter.api.Disabled
*/
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@ExtendWith(EnabledIfCondition.class)
public @interface EnabledIf {
/**
* Alias for {@link #expression}; only intended to be used if an
* explicit {@link #reason} is not provided.
*
* @see #expression
*/
@AliasFor("expression")
String value() default "";
/**
* The expression that will be evaluated to determine if the annotated test
* class or test method is <em>enabled</em>.
*
* <p>If the expression evaluates to {@link Boolean#TRUE} or a {@link String}
* equal to {@code "true"} (ignoring case), the test will be enabled.
*
* <p>Expressions can be any of the following.
*
* <ul>
* <li>Spring Expression Language (SpEL) expression &mdash; for example:
* <pre style="code">@EnabledIf("#{systemProperties['os.name'].toLowerCase().contains('mac')}")</pre>
* <li>Placeholder for a property available in the Spring
* {@link org.springframework.core.env.Environment Environment} &mdash; for example:
* <pre style="code">@EnabledIf("${smoke.tests.enabled}")</pre>
* <li>Text literal &mdash; for example:
* <pre style="code">@EnabledIf("true")</pre>
* </ul>
*
* <p>Note, however, that a <em>text literal</em> which is not the result of
* dynamic resolution of a property placeholder is of zero practical value
* since {@code @EnabledIf("false")} is equivalent to {@code @Disabled}
* and {@code @EnabledIf("true")} is logically meaningless.
*
* @see #reason
* @see #value
*/
@AliasFor("value")
String expression() default "";
/**
* The reason this test is enabled.
*
* @see #expression
*/
String reason() default "";
}

66
spring-test/src/main/java/org/springframework/test/context/junit/jupiter/EnabledIfCondition.java Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2002-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.context.junit.jupiter;
import org.junit.jupiter.api.extension.ConditionEvaluationResult;
import org.junit.jupiter.api.extension.ContainerExecutionCondition;
import org.junit.jupiter.api.extension.ContainerExtensionContext;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.TestExecutionCondition;
import org.junit.jupiter.api.extension.TestExtensionContext;
/**
* {@code EnabledIfCondition} is a composite {@link ContainerExecutionCondition}
* and {@link TestExecutionCondition} that supports the {@link EnabledIf @EnabledIf}
* annotation when using the <em>Spring TestContext Framework</em> in conjunction
* with JUnit 5's <em>Jupiter</em> programming model.
*
* <p>Any attempt to use the {@code EnabledIfCondition} without the presence of
* {@link EnabledIf @EnabledIf} will result in an <em>enabled</em>
* {@link ConditionEvaluationResult}.
*
* @author Sam Brannen
* @since 5.0
* @see EnabledIf
* @see DisabledIf
* @see SpringExtension
*/
public class EnabledIfCondition extends AbstractExpressionEvaluatingCondition {
/**
* Containers are enabled if {@code @EnabledIf} is present on the test class
* and the configured expression evaluates to {@code true}.
*/
@Override
public ConditionEvaluationResult evaluate(ContainerExtensionContext context) {
return evaluateEnabledIf(context);
}
/**
* Tests are enabled if {@code @EnabledIf} is present on the test method
* and the configured expression evaluates to {@code true}.
*/
@Override
public ConditionEvaluationResult evaluate(TestExtensionContext context) {
return evaluateEnabledIf(context);
}
private ConditionEvaluationResult evaluateEnabledIf(ExtensionContext context) {
return evaluateAnnotation(EnabledIf.class, EnabledIf::expression, EnabledIf::reason, true, context);
}
}