Improve Bean Override by-name integration tests

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

@@ -40,21 +40,12 @@ public class TestBeanForByNameLookupIntegrationTests {
 	@TestBean(name = "field")
 	String field;
 
-	@TestBean(name = "nestedField")
-	String nestedField;
-
 	@TestBean(name = "field")
-	String renamed1;
-
-	@TestBean(name = "nestedField")
-	String renamed2;
+	String renamed;
 
 	@TestBean(name = "methodRenamed1", methodName = "field")
 	String methodRenamed1;
 
-	@TestBean(name = "methodRenamed2", methodName = "nestedField")
-	String methodRenamed2;
-
 	static String field() {
 		return "fieldOverride";
 	}
@@ -66,62 +57,108 @@ public class TestBeanForByNameLookupIntegrationTests {
 	@Test
 	void fieldHasOverride(ApplicationContext ctx) {
 		assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
-		assertThat(this.field).as("injection point").isEqualTo("fieldOverride");
+		assertThat(field).as("injection point").isEqualTo("fieldOverride");
 	}
 
 	@Test
 	void renamedFieldHasOverride(ApplicationContext ctx) {
 		assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
-		assertThat(this.renamed1).as("injection point").isEqualTo("fieldOverride");
+		assertThat(renamed).as("injection point").isEqualTo("fieldOverride");
 	}
 
 	@Test
 	void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
 		assertThat(ctx.getBean("methodRenamed1")).as("applicationContext").isEqualTo("fieldOverride");
-		assertThat(this.methodRenamed1).as("injection point").isEqualTo("fieldOverride");
+		assertThat(methodRenamed1).as("injection point").isEqualTo("fieldOverride");
 	}
 
 
 	@Nested
-	@DisplayName("With @TestBean in enclosing class")
+	@DisplayName("With @TestBean in enclosing class and in @Nested class")
 	public class TestBeanFieldInEnclosingClassTests {
 
+		@TestBean(name = "nestedField")
+		String nestedField;
+
+		@TestBean(name = "nestedField")
+		String renamed2;
+
+		@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 renamedFieldHasOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+			assertThat(renamed).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 renamedFieldHasOverride(ApplicationContext ctx) {
+		void nestedRenamedFieldHasOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
 			assertThat(renamed2).isEqualTo("nestedFieldOverride");
 		}
 
 		@Test
-		void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
+		void nestedFieldWithMethodNameHasOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("methodRenamed2")).as("applicationContext").isEqualTo("nestedFieldOverride");
 			assertThat(methodRenamed2).isEqualTo("nestedFieldOverride");
 		}
 
 		@Nested
-		@DisplayName("With @TestBean in the enclosing class of the enclosing class")
+		@DisplayName("With @TestBean in the enclosing classes")
 		public class TestBeanFieldInEnclosingClassLevel2Tests {
 
 			@Test
 			void fieldHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+				assertThat(field).as("injection point").isEqualTo("fieldOverride");
+			}
+
+			@Test
+			void renamedFieldHasOverride(ApplicationContext ctx) {
+				assertThat(ctx.getBean("field")).as("applicationContext").isEqualTo("fieldOverride");
+				assertThat(renamed).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 renamedFieldHasOverride(ApplicationContext ctx) {
+			void nestedRenamedFieldHasOverride(ApplicationContext ctx) {
 				assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
 				assertThat(renamed2).isEqualTo("nestedFieldOverride");
 			}
 
 			@Test
-			void fieldWithMethodNameHasOverride(ApplicationContext ctx) {
+			void nestedFieldWithMethodNameHasOverride(ApplicationContext ctx) {
 				assertThat(ctx.getBean("methodRenamed2")).as("applicationContext").isEqualTo("nestedFieldOverride");
 				assertThat(methodRenamed2).isEqualTo("nestedFieldOverride");
 			}
@@ -136,9 +173,9 @@ public class TestBeanForByNameLookupIntegrationTests {
 		String nestedField2;
 
 		@Test
-		void fieldHasOverride(ApplicationContext ctx) {
+		void nestedFieldHasOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
-			assertThat(this.nestedField2).isEqualTo("nestedFieldOverride");
+			assertThat(nestedField2).isEqualTo("nestedFieldOverride");
 		}
 
 		@Nested
@@ -149,9 +186,9 @@ public class TestBeanForByNameLookupIntegrationTests {
 			String nestedField2;
 
 			@Test
-			void fieldHasOverride(ApplicationContext ctx) {
+			void nestedFieldHasOverride(ApplicationContext ctx) {
 				assertThat(ctx.getBean("nestedField")).as("applicationContext").isEqualTo("nestedFieldOverride");
-				assertThat(this.nestedField2).isEqualTo("nestedFieldOverride");
+				assertThat(nestedField2).isEqualTo("nestedFieldOverride");
 			}
 		}
 	}

spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanForByNameLookupIntegrationTests.java

@@ -20,6 +20,8 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -32,6 +34,10 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Integration tests for {@link MockitoBean} that use by-name lookup.
+ *
+ * @author Simon Baslé
+ * @author Sam Brannen
+ * @since 6.2
  */
 @SpringJUnitConfig
 public class MockitoBeanForByNameLookupIntegrationTests {
@@ -39,20 +45,11 @@ public class MockitoBeanForByNameLookupIntegrationTests {
 	@MockitoBean("field")
 	ExampleService field;
 
-	@MockitoBean("nestedField")
-	ExampleService nestedField;
-
 	@MockitoBean("field")
-	ExampleService renamed1;
-
-	@MockitoBean("nestedField")
-	ExampleService renamed2;
+	ExampleService renamed;
 
 	@MockitoBean("nonExistingBean")
-	ExampleService nonExisting1;
-
-	@MockitoBean("nestedNonExistingBean")
-	ExampleService nonExisting2;
+	ExampleService nonExisting;
 
 
 	@Test
@@ -60,11 +57,11 @@ public class MockitoBeanForByNameLookupIntegrationTests {
 		assertThat(ctx.getBean("field"))
 				.isInstanceOf(ExampleService.class)
 				.satisfies(MockitoAssertions::assertIsMock)
-				.isSameAs(this.field)
-				.isSameAs(this.renamed1);
+				.isSameAs(field)
+				.isSameAs(renamed);
 
-		assertThat(this.field.greeting()).as("mocked greeting").isNull();
-		assertThat(this.renamed1.greeting()).as("mocked greeting").isNull();
+		assertThat(field.greeting()).as("mocked greeting").isNull();
+		assertThat(renamed.greeting()).as("mocked greeting").isNull();
 	}
 
 	@Test
@@ -72,31 +69,75 @@ public class MockitoBeanForByNameLookupIntegrationTests {
 		assertThat(ctx.getBean("nonExistingBean"))
 				.isInstanceOf(ExampleService.class)
 				.satisfies(MockitoAssertions::assertIsMock)
-				.isSameAs(this.nonExisting1);
+				.isSameAs(nonExisting);
 
-		assertThat(this.nonExisting1.greeting()).as("mocked greeting").isNull();
+		assertThat(nonExisting.greeting()).as("mocked greeting").isNull();
 	}
 
 
 	@Nested
-	@DisplayName("With @MockitoBean in enclosing class")
+	@DisplayName("With @MockitoBean in enclosing class and in @Nested class")
 	public class MockitoBeanNestedTests {
 
+		@Autowired
+		@Qualifier("field")
+		ExampleService localField;
+
+		@Autowired
+		@Qualifier("field")
+		ExampleService localRenamed;
+
+		@Autowired
+		@Qualifier("nonExistingBean")
+		ExampleService localNonExisting;
+
+		@MockitoBean("nestedField")
+		ExampleService nestedField;
+
+		@MockitoBean("nestedField")
+		ExampleService nestedRenamed;
+
+		@MockitoBean("nestedNonExistingBean")
+		ExampleService nestedNonExisting;
+
+
 		@Test
 		void fieldAndRenamedFieldHaveSameOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("field"))
+					.isInstanceOf(ExampleService.class)
+					.satisfies(MockitoAssertions::assertIsMock)
+					.isSameAs(localField)
+					.isSameAs(localRenamed);
+
+			assertThat(localField.greeting()).as("mocked greeting").isNull();
+			assertThat(localRenamed.greeting()).as("mocked greeting").isNull();
+		}
+
+		@Test
+		void fieldIsMockedWhenNoOriginalBean(ApplicationContext ctx) {
+			assertThat(ctx.getBean("nonExistingBean"))
+					.isInstanceOf(ExampleService.class)
+					.satisfies(MockitoAssertions::assertIsMock)
+					.isSameAs(localNonExisting);
+
+			assertThat(localNonExisting.greeting()).as("mocked greeting").isNull();
+		}
+
+		@Test
+		void nestedFieldAndRenamedFieldHaveSameOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("nestedField"))
 					.isInstanceOf(ExampleService.class)
 					.satisfies(MockitoAssertions::assertIsMock)
 					.isSameAs(nestedField)
-					.isSameAs(renamed2);
+					.isSameAs(nestedRenamed);
 		}
 
 		@Test
-		void fieldIsMockedWhenNoOriginalBean(ApplicationContext ctx) {
+		void nestedFieldIsMockedWhenNoOriginalBean(ApplicationContext ctx) {
 			assertThat(ctx.getBean("nestedNonExistingBean"))
 					.isInstanceOf(ExampleService.class)
 					.satisfies(MockitoAssertions::assertIsMock)
-					.isSameAs(nonExisting2);
+					.isSameAs(nestedNonExisting);
 		}
 	}
 

spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanForByNameLookupIntegrationTests.java

@@ -20,6 +20,8 @@ import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
@@ -45,7 +47,7 @@ public class MockitoSpyBeanForByNameLookupIntegrationTests {
 	ExampleService field;
 
 	@MockitoSpyBean("field1")
-	ExampleService renamed1;
+	ExampleService renamed;
 
 
 	@Test
@@ -63,23 +65,51 @@ public class MockitoSpyBeanForByNameLookupIntegrationTests {
 		assertThat(ctx.getBean("field1"))
 				.isInstanceOf(ExampleService.class)
 				.satisfies(MockitoAssertions::assertIsSpy)
-				.isSameAs(renamed1);
+				.isSameAs(renamed);
 
-		assertThat(renamed1.greeting()).isEqualTo("bean1");
+		assertThat(renamed.greeting()).isEqualTo("bean1");
 	}
 
 	@Nested
 	@DisplayName("With @MockitoSpyBean in enclosing class and in @Nested class")
 	public class MockitoSpyBeanNestedTests {
 
+		@Autowired
+		@Qualifier("field1")
+		ExampleService localField;
+
+		@Autowired
+		@Qualifier("field1")
+		ExampleService localRenamed;
+
 		@MockitoSpyBean("field2")
 		ExampleService nestedField;
 
 		@MockitoSpyBean("field2")
-		ExampleService renamed2;
+		ExampleService nestedRenamed;
 
 		@Test
 		void fieldHasOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("field1"))
+					.isInstanceOf(ExampleService.class)
+					.satisfies(MockitoAssertions::assertIsSpy)
+					.isSameAs(localField);
+
+			assertThat(localField.greeting()).isEqualTo("bean1");
+		}
+
+		@Test
+		void renamedFieldHasOverride(ApplicationContext ctx) {
+			assertThat(ctx.getBean("field1"))
+					.isInstanceOf(ExampleService.class)
+					.satisfies(MockitoAssertions::assertIsSpy)
+					.isSameAs(localRenamed);
+
+			assertThat(localRenamed.greeting()).isEqualTo("bean1");
+		}
+
+		@Test
+		void nestedFieldHasOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("field2"))
 					.isInstanceOf(ExampleService.class)
 					.satisfies(MockitoAssertions::assertIsSpy)
@@ -89,13 +119,13 @@ public class MockitoSpyBeanForByNameLookupIntegrationTests {
 		}
 
 		@Test
-		void renamedFieldHasOverride(ApplicationContext ctx) {
+		void nestedRenamedFieldHasOverride(ApplicationContext ctx) {
 			assertThat(ctx.getBean("field2"))
 					.isInstanceOf(ExampleService.class)
 					.satisfies(MockitoAssertions::assertIsSpy)
-					.isSameAs(renamed2);
+					.isSameAs(nestedRenamed);
 
-			assertThat(renamed2.greeting()).isEqualTo("bean2");
+			assertThat(nestedRenamed.greeting()).isEqualTo("bean2");
 		}
 	}