Support JUnit Jupiter ExtensionContextScope.TEST_METHOD

Historically, @⁠Autowired fields in an enclosing class of a @⁠Nested
test class have been injected from the ApplicationContext for the
enclosing class. If the enclosing test class and @⁠Nested test class
share the same ApplicationContext configuration, things work as
developers expect. However, if the enclosing class and @⁠Nested test
class have different ApplicationContexts, that can lead to
difficult-to-debug scenarios. For example, a bean injected into the
enclosing test class will not participate in a test-managed transaction
in the @⁠Nested test class (see gh-34576).

JUnit Jupiter 5.12 introduced a new ExtensionContextScope feature which
allows the SpringExtension to behave the same for @⁠Autowired fields as
it already does for @⁠Autowired arguments in lifecycle and test
methods. Specifically, if a developer sets the ExtensionContextScope to
TEST_METHOD — for example, by configuring the following configuration
parameter as a JVM system property or in a `junit-platform.properties`
file — the SpringExtension already supports dependency injection from
the current, @⁠Nested ApplicationContext in @⁠Autowired fields in an
enclosing class of the @⁠Nested test class.

junit.jupiter.extensions.testinstantiation.extensioncontextscope.default=test_method

However, there are two scenarios that fail as of Spring Framework
6.2.12.

1. @⁠TestConstructor configuration in @⁠Nested class hierarchies.
2. Field injection for bean overrides (such as @⁠MockitoBean) in
   @⁠Nested class hierarchies.

Commit 82c34f7 fixed the SpringExtension to support scenario #2
above.

To fix scenario #1, this commit revises
BeanOverrideTestExecutionListener's injectField() implementation to
look up the fields to inject for the "current test instance" instead of
for the "current test class".

This commit also introduces tests for both scenarios.

See gh-34576
See gh-35676
Closes gh-35680

Author: sbrannen

spring-test/src/main/java/org/springframework/test/context/bean/override/BeanOverrideTestExecutionListener.java

@@ -93,9 +93,17 @@ public void beforeTestMethod(TestContext testContext) throws Exception {
 	 * a corresponding bean override instance.
 	 */
 	private static void injectFields(TestContext testContext) {
-		List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(testContext.getTestClass());
+		Object testInstance = testContext.getTestInstance();
+		// Since JUnit Jupiter 5.12, if the SpringExtension is used with Jupiter's
+		// ExtensionContextScope.TEST_METHOD mode, the value returned from
+		// testContext.getTestClass() may refer to the declaring class of the test
+		// method which is about to be invoked (which may be in a @Nested class
+		// within the class for the test instance). Thus, we use the class for the
+		// test instance as the "test class".
+		Class<?> testClass = testInstance.getClass();
+
+		List<BeanOverrideHandler> handlers = BeanOverrideHandler.forTestClass(testClass);
 		if (!handlers.isEmpty()) {
-			Object testInstance = testContext.getTestInstance();
 			ApplicationContext applicationContext = testContext.getApplicationContext();
 
 			Assert.state(applicationContext.containsBean(BeanOverrideRegistry.BEAN_NAME), () -> """

spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanByNameLookupIntegrationTests.java renamed to spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanByNameLookupTestClassScopedExtensionContextIntegrationTests.java

@@ -19,6 +19,7 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.TestInstantiationAwareExtension.ExtensionContextScope;
 
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
@@ -28,14 +29,15 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Integration tests for {@link TestBean} that use by-name lookup.
+ * Integration tests for {@link TestBean} that use by-name lookup with test class
+ * {@link ExtensionContextScope}.
  *
  * @author Simon Baslé
  * @author Sam Brannen
  * @since 6.2
  */
 @SpringJUnitConfig
-public class TestBeanByNameLookupIntegrationTests {
+public class TestBeanByNameLookupTestClassScopedExtensionContextIntegrationTests {
 
 	@TestBean(name = "field")
 	String field;

spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanByNameLookupTestMethodScopedExtensionContextIntegrationTests.java

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2002-present 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.bean.override.convention;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.TestInstantiationAwareExtension.ExtensionContextScope;
+import org.junit.platform.testkit.engine.EngineTestKit;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.extension.TestInstantiationAwareExtension.ExtensionContextScope.DEFAULT_SCOPE_PROPERTY_NAME;
+import static org.junit.jupiter.api.extension.TestInstantiationAwareExtension.ExtensionContextScope.TEST_METHOD;
+import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
+
+
+/**
+ * Integration tests for {@link TestBean} that use by-name lookup with
+ * {@link ExtensionContextScope#TEST_METHOD}.
+ *
+ * @author Simon Baslé
+ * @author Sam Brannen
+ * @since 6.2.13
+ */
+public class TestBeanByNameLookupTestMethodScopedExtensionContextIntegrationTests {
+
+	@Test
+	void runTests() {
+		EngineTestKit.engine("junit-jupiter")
+				.configurationParameter(DEFAULT_SCOPE_PROPERTY_NAME, TEST_METHOD.name())
+				.selectors(selectClass(TestCase.class))
+				.execute()
+				.testEvents()
+				.assertStatistics(stats -> stats.started(12).succeeded(12).failed(0));
+	}
+
+
+	@SpringJUnitConfig
+	public static class TestCase {
+
+		@TestBean(name = "field")
+		String field;
+
+		@TestBean(name = "methodRenamed1", methodName = "field")
+		String methodRenamed1;
+
+		static String field() {
+			return "fieldOverride";
+		}
+
+		static String nestedField() {
+			return "nestedFieldOverride";
+		}
+
+		@Test
+		void fieldHasOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+			assertThat(field).as("injection point").isEqualTo("fieldOverride");
+		}
+
+		@Test
+		void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("methodRenamed1")).as("applicationContext").isEqualTo("fieldOverride");
+			assertThat(methodRenamed1).as("injection point").isEqualTo("fieldOverride");
+		}
+
+
+		@Nested
+		@DisplayName("With @TestBean in enclosing class and in @Nested class")
+		public class TestBeanFieldInEnclosingClassTestCase {
+
+			@TestBean(name = "nestedField")
+			String nestedField;
+
+			@TestBean(name = "methodRenamed2", methodName = "nestedField")
+			String methodRenamed2;
+
+
+			@Test
+			void fieldHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+				assertThat(field).as("injection point").isEqualTo("fieldOverride");
+			}
+
+			@Test
+			void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("methodRenamed1")).as("applicationContext").isEqualTo("fieldOverride");
+				assertThat(methodRenamed1).as("injection point").isEqualTo("fieldOverride");
+			}
+
+			@Test
+			void nestedFieldHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
+				assertThat(nestedField).isEqualTo("nestedFieldOverride");
+			}
+
+			@Test
+			void nestedFieldWithMethodNameHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("methodRenamed2")).as("applicationContext").isEqualTo("nestedFieldOverride");
+				assertThat(methodRenamed2).isEqualTo("nestedFieldOverride");
+			}
+
+			@Nested
+			@DisplayName("With @TestBean in the enclosing classes")
+			public class TestBeanFieldInEnclosingClassLevel2TestCase {
+
+				@Test
+				void fieldHasOverride(ApplicationContext ctx) {
+					assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+					assertThat(field).as("injection point").isEqualTo("fieldOverride");
+				}
+
+				@Test
+				void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
+					assertThat(ctx.getBean("methodRenamed1")).as("applicationContext").isEqualTo("fieldOverride");
+					assertThat(methodRenamed1).as("injection point").isEqualTo("fieldOverride");
+				}
+
+				@Test
+				void nestedFieldHasOverride(ApplicationContext ctx) {
+					assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
+					assertThat(nestedField).isEqualTo("nestedFieldOverride");
+				}
+
+				@Test
+				void nestedFieldWithMethodNameHasOverride(ApplicationContext ctx) {
+					assertThat(ctx.getBean("methodRenamed2")).as("applicationContext").isEqualTo("nestedFieldOverride");
+					assertThat(methodRenamed2).isEqualTo("nestedFieldOverride");
+				}
+			}
+		}
+
+		@Nested
+		@DisplayName("With factory method in enclosing class")
+		public class TestBeanFactoryMethodInEnclosingClassTestCase {
+
+			@TestBean(methodName = "nestedField", name = "nestedField")
+			String nestedField;
+
+			@Test
+			void nestedFieldHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
+				assertThat(nestedField).isEqualTo("nestedFieldOverride");
+			}
+
+			@Nested
+			@DisplayName("With factory method in the enclosing class of the enclosing class")
+			public class TestBeanFactoryMethodInEnclosingClassLevel2TestCase {
+
+				@TestBean(methodName = "nestedField", name = "nestedNestedField")
+				String nestedNestedField;
+
+				@Test
+				void nestedFieldHasOverride(ApplicationContext ctx) {
+					assertThat(ctx.getBean("nestedNestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
+					assertThat(nestedNestedField).isEqualTo("nestedFieldOverride");
+				}
+			}
+		}
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	static class Config {
+
+		@Bean("field")
+		String bean1() {
+			return "prod";
+		}
+
+		@Bean("nestedField")
+		String bean2() {
+			return "nestedProd";
+		}
+
+		@Bean("methodRenamed1")
+		String bean3() {
+			return "Prod";
+		}
+
+		@Bean("methodRenamed2")
+		String bean4() {
+			return "NestedProd";
+		}
+	}
+
+}

spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanByNameLookupIntegrationTests.java renamed to spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanByNameLookupTestClassScopedExtensionContextIntegrationTests.java

@@ -19,6 +19,7 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.TestInstantiationAwareExtension.ExtensionContextScope;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -33,14 +34,15 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * Integration tests for {@link MockitoBean} that use by-name lookup.
+ * Integration tests for {@link MockitoBean} that use by-name lookup with test class
+ * {@link ExtensionContextScope}.
  *
  * @author Simon Baslé
  * @author Sam Brannen
  * @since 6.2
  */
 @SpringJUnitConfig
-public class MockitoBeanByNameLookupIntegrationTests {
+public class MockitoBeanByNameLookupTestClassScopedExtensionContextIntegrationTests {
 
 	@MockitoBean("field")
 	ExampleService field;