diff --git a/spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanForByNameLookupIntegrationTests.java b/spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanForByNameLookupIntegrationTests.java index 8274cd5ccfc..e350535623c 100644 --- a/spring-test/src/test/java/org/springframework/test/context/bean/override/convention/TestBeanForByNameLookupIntegrationTests.java +++ b/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"); } } } diff --git a/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanForByNameLookupIntegrationTests.java b/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanForByNameLookupIntegrationTests.java index d7ddafaa43c..d8cf06026e8 100644 --- a/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoBeanForByNameLookupIntegrationTests.java +++ b/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); } } diff --git a/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanForByNameLookupIntegrationTests.java b/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanForByNameLookupIntegrationTests.java index 17989e22d14..be824c52e21 100644 --- a/spring-test/src/test/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanForByNameLookupIntegrationTests.java +++ b/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"); } }