Skip to content

Commit

Permalink
Honor class-level @DirtiesContext if test class is disabled via SpEL
Browse files Browse the repository at this point in the history
Prior to this commit, if a test class annotated with @DirtiesContext
and @EnabledIf/@DisabledIf with `loadContext = true` was disabled due
to the evaluated SpEL expression, the ApplicationContext would not be
marked as dirty and closed.

The reason is that @EnabledIf/@DisabledIf are implemented via JUnit
Jupiter's ExecutionCondition extension API which results in the entire
test class (as well as any associated extension callbacks) being
skipped if the condition evaluates to `disabled`. This effectively
prevents any of Spring's TestExecutionListener APIs from being invoked.
Consequently, the DirtiesContextTestExecutionListener does not get a
chance to honor the class-level @DirtiesContext declaration.

This commit fixes this by implementing part of the logic of
DirtiesContextTestExecutionListener in
AbstractExpressionEvaluatingCondition (i.e., the base class for
@EnabledIf/@DisabledIf support). Specifically, if the test class for an
eagerly loaded ApplicationContext is disabled,
AbstractExpressionEvaluatingCondition will now mark the test
ApplicationContext as dirty if the test class is annotated with
@DirtiesContext.

Closes spring-projectsgh-26694
  • Loading branch information
sbrannen authored and lxbzmy committed Mar 26, 2022
1 parent 9212bb2 commit 1d46e79
Show file tree
Hide file tree
Showing 5 changed files with 241 additions and 5 deletions.
@@ -1,5 +1,5 @@
/*
* Copyright 2002-2017 the original author or authors.
* Copyright 2002-2021 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.
Expand Down Expand Up @@ -34,6 +34,9 @@
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.HierarchyMode;
import org.springframework.test.context.TestContextAnnotationUtils;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

Expand Down Expand Up @@ -105,6 +108,7 @@ protected <A extends Annotation> ConditionEvaluationResult evaluateAnnotation(Cl

boolean loadContext = loadContextExtractor.apply(annotation.get());
boolean evaluatedToTrue = evaluateExpression(expression, loadContext, annotationType, context);
ConditionEvaluationResult result;

if (evaluatedToTrue) {
String adjective = (enabledOnTrue ? "enabled" : "disabled");
Expand All @@ -114,7 +118,7 @@ protected <A extends Annotation> ConditionEvaluationResult evaluateAnnotation(Cl
if (logger.isInfoEnabled()) {
logger.info(reason);
}
return (enabledOnTrue ? ConditionEvaluationResult.enabled(reason)
result = (enabledOnTrue ? ConditionEvaluationResult.enabled(reason)
: ConditionEvaluationResult.disabled(reason));
}
else {
Expand All @@ -124,9 +128,26 @@ protected <A extends Annotation> ConditionEvaluationResult evaluateAnnotation(Cl
if (logger.isDebugEnabled()) {
logger.debug(reason);
}
return (enabledOnTrue ? ConditionEvaluationResult.disabled(reason) :
result = (enabledOnTrue ? ConditionEvaluationResult.disabled(reason) :
ConditionEvaluationResult.enabled(reason));
}

// If we eagerly loaded the ApplicationContext to evaluate SpEL expressions
// and the test class ends up being disabled, we have to check if the
// user asked for the ApplicationContext to be closed via @DirtiesContext,
// since the DirtiesContextTestExecutionListener will never be invoked for
// a disabled test class.
// See https://github.com/spring-projects/spring-framework/issues/26694
if (loadContext && result.isDisabled() && element instanceof Class) {
Class<?> testClass = (Class<?>) element;
DirtiesContext dirtiesContext = TestContextAnnotationUtils.findMergedAnnotation(testClass, DirtiesContext.class);
if (dirtiesContext != null) {
HierarchyMode hierarchyMode = dirtiesContext.hierarchyMode();
SpringExtension.getTestContextManager(context).getTestContext().markApplicationContextDirty(hierarchyMode);
}
}

return result;
}

private <A extends Annotation> boolean evaluateExpression(String expression, boolean loadContext,
Expand Down
@@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2021 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.
Expand Down Expand Up @@ -287,7 +287,7 @@ public static ApplicationContext getApplicationContext(ExtensionContext context)
* Get the {@link TestContextManager} associated with the supplied {@code ExtensionContext}.
* @return the {@code TestContextManager} (never {@code null})
*/
private static TestContextManager getTestContextManager(ExtensionContext context) {
static TestContextManager getTestContextManager(ExtensionContext context) {
Assert.notNull(context, "ExtensionContext must not be null");
Class<?> testClass = context.getRequiredTestClass();
Store store = getStore(context);
Expand Down
@@ -0,0 +1,107 @@
/*
* Copyright 2002-2021 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
*
* https://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.util.concurrent.atomic.AtomicBoolean;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.platform.testkit.engine.EngineTestKit;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.annotation.DirtiesContext;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;

/**
* Integration tests which verify support for {@link DisabledIf @DisabledIf} in
* conjunction with {@link DirtiesContext @DirtiesContext} and the
* {@link SpringExtension} in a JUnit Jupiter environment.
*
* @author Sam Brannen
* @since 5.2.14
* @see EnabledIfAndDirtiesContextTests
*/
class DisabledIfAndDirtiesContextTests {

private static AtomicBoolean contextClosed = new AtomicBoolean();


@BeforeEach
void reset() {
contextClosed.set(false);
}

@Test
void contextShouldBeClosedForEnabledTestClass() {
assertThat(contextClosed).as("context closed").isFalse();
EngineTestKit.engine("junit-jupiter").selectors(
selectClass(EnabledAndDirtiesContextTestCase.class))//
.execute()//
.testEvents()//
.assertStatistics(stats -> stats.started(1).succeeded(1).failed(0));
assertThat(contextClosed).as("context closed").isTrue();
}

@Test
void contextShouldBeClosedForDisabledTestClass() {
assertThat(contextClosed).as("context closed").isFalse();
EngineTestKit.engine("junit-jupiter").selectors(
selectClass(DisabledAndDirtiesContextTestCase.class))//
.execute()//
.testEvents()//
.assertStatistics(stats -> stats.started(0).succeeded(0).failed(0));
assertThat(contextClosed).as("context closed").isTrue();
}


@SpringJUnitConfig(Config.class)
@DisabledIf(expression = "false", loadContext = true)
@DirtiesContext
static class EnabledAndDirtiesContextTestCase {

@Test
void test() {
/* no-op */
}
}

@SpringJUnitConfig(Config.class)
@DisabledIf(expression = "true", loadContext = true)
@DirtiesContext
static class DisabledAndDirtiesContextTestCase {

@Test
void test() {
fail("This test must be disabled");
}
}

@Configuration
static class Config {

@Bean
DisposableBean disposableBean() {
return () -> contextClosed.set(true);
}
}

}
@@ -0,0 +1,107 @@
/*
* Copyright 2002-2021 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
*
* https://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.util.concurrent.atomic.AtomicBoolean;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.platform.testkit.engine.EngineTestKit;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.annotation.DirtiesContext;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.fail;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;

/**
* Integration tests which verify support for {@link EnabledIf @EnabledIf} in
* conjunction with {@link DirtiesContext @DirtiesContext} and the
* {@link SpringExtension} in a JUnit Jupiter environment.
*
* @author Sam Brannen
* @since 5.2.14
* @see DisabledIfAndDirtiesContextTests
*/
class EnabledIfAndDirtiesContextTests {

private static AtomicBoolean contextClosed = new AtomicBoolean();


@BeforeEach
void reset() {
contextClosed.set(false);
}

@Test
void contextShouldBeClosedForEnabledTestClass() {
assertThat(contextClosed).as("context closed").isFalse();
EngineTestKit.engine("junit-jupiter").selectors(
selectClass(EnabledAndDirtiesContextTestCase.class))//
.execute()//
.testEvents()//
.assertStatistics(stats -> stats.started(1).succeeded(1).failed(0));
assertThat(contextClosed).as("context closed").isTrue();
}

@Test
void contextShouldBeClosedForDisabledTestClass() {
assertThat(contextClosed).as("context closed").isFalse();
EngineTestKit.engine("junit-jupiter").selectors(
selectClass(DisabledAndDirtiesContextTestCase.class))//
.execute()//
.testEvents()//
.assertStatistics(stats -> stats.started(0).succeeded(0).failed(0));
assertThat(contextClosed).as("context closed").isTrue();
}


@SpringJUnitConfig(Config.class)
@EnabledIf(expression = "true", loadContext = true)
@DirtiesContext
static class EnabledAndDirtiesContextTestCase {

@Test
void test() {
/* no-op */
}
}

@SpringJUnitConfig(Config.class)
@EnabledIf(expression = "false", loadContext = true)
@DirtiesContext
static class DisabledAndDirtiesContextTestCase {

@Test
void test() {
fail("This test must be disabled");
}
}

@Configuration
static class Config {

@Bean
DisposableBean disposableBean() {
return () -> contextClosed.set(true);
}
}

}
1 change: 1 addition & 0 deletions spring-test/src/test/resources/log4j2-test.xml
Expand Up @@ -25,6 +25,7 @@
<Logger name="org.springframework.test.context.support.DelegatingSmartContextLoader" level="info" />
<Logger name="org.springframework.test.context.support.AbstractGenericContextLoader" level="info" />
<Logger name="org.springframework.test.context.support.AnnotationConfigContextLoader" level="info" />
<Logger name="org.springframework.test.context.support.AbstractDirtiesContextTestExecutionListener" level="warn" />
<Logger name="org.springframework.test.context.support.TestPropertySourceUtils" level="trace" />
<Logger name="org.springframework.beans" level="warn" />
<Logger name="org.springframework.test.web.servlet.result" level="debug" />
Expand Down

0 comments on commit 1d46e79

Please sign in to comment.