`@MockitoBean` does not get reset in inherited `@Nested` tests

[stan-borissov]

In the snippet below, the ServiceB @MockitoBean is not reset between firstNestedTest() and secondNestedTest(), but it should be. This causes secondNestedTest to fail on verify(serviceB).bar();, as there are 2 invocations instead of just the expected 1.

Note that the @Import(ServiceC.class) on ChildTests is not required for the test as such, but causes (by some mysterious means) the failure to reset ServiceB, as removing the @Import will make the test pass.

Spring Boot version is 3.4.5.

This issue may be related to spring-projects/spring-boot#12470.

Services

@Component
public class ServiceA {
    @Autowired
    public ServiceB serviceB;

    public void foo() {
        serviceB.bar();
    }
}

@Component
public class ServiceB {
    public void bar() {
    }
}

@Component
public class ServiceC {
}

Test

@SpringBootTest
public abstract class ParentTests {

    @MockBean
    ServiceB serviceB;
    @Autowired
    ServiceA serviceA;

    @Nested
    class NestedTest {

        @Test
        void firstNestedTest() {
            serviceA.foo();
            verify(serviceB).bar();
        }

        @Test
        void secondNestedTest() {
            serviceA.foo();
            verify(serviceB).bar();
        }
    }
}

@Import(ServiceC.class)
public class ChildTests extends ParentTests {
}

[LiamMacP-HO]

HI @snicoll + @sbrannen, just wondered if there was an update on this?

I've just come across this in one of our tests and used Mockito.reset() in an @AfterEach on the @MockitoBean to get around it for now.

Version: Spring Boot 3.5.10

[sbrannen]

I was able reproduce this without Spring Boot in the picture as follows.

@SpringJUnitConfig({ ServiceA.class, ServiceB.class })
public class ParentTests {

	@MockitoBean
	ServiceB serviceB;

	@Autowired
	ServiceA serviceA;

	@Test
	void firstTest() {
		serviceA.foo();
		verify(serviceB).bar();
	}

	@Test
	void secondTest() {
		serviceA.foo();
		verify(serviceB).bar();
	}

	@Nested
	class NestedTests {

		@Test
		void firstNestedTest() {
			serviceA.foo();
			verify(serviceB).bar();
		}

		@Test
		void secondNestedTest() {
			serviceA.foo();
			verify(serviceB).bar();
		}
	}
}

// @SpringExtensionConfig(useTestClassScopedExtensionContext = true)
@ContextConfiguration(classes = ServiceC.class)
public class ChildTests extends ParentTests {
}

[sbrannen]

Hi @stan-borissov,

First and foremost, congratulations on opening your first GitHub issue ever! 👍🏻

Secondly, I apologize that this issue has not been triaged until now.

In the snippet below, the ServiceB MockBean is not reset between firstTest and secondTest, but it should be. This causes secondTest to fail on verify(serviceB).bar();, as there are 2 invocations instead of just the expected 1.

The issue you encountered is actually to be expected (though admittedly completely nonintuitive) and is due to a combination of how Spring's annotation search algorithms work and the behavior of the ExtensionContext supplied to the SpringExtension by JUnit Jupiter.

If you run your tests on Spring Framework 7 or higher, you will notice that they actually pass unmodified. The reason is that we switched to a test-method scoped ExtensionContext in 7.0 (see #35697), and that causes the ServiceA and ServiceB fields in ParentTests to be injected from the ApplicationContext for ParentTests (not ChildTests) when executing the test methods in NestedTests even while running with ChildTests as the runtime enclosing type.

Note, however, that there are actually 2 distinct application contexts loaded in this scenario: one for ParentTests (and NestedTests) and another for ChildTests.

In the above passing scenario on Spring Framework 7, the ApplicationContext for ParentTests is used for firstNestedTest() and secondNestedTest(). Consequently, the @MockitoBean gets reset appropriately between the execution of test methods in NestedTests.

Note: if you annotate ChildTests with @SpringExtensionConfig(useTestClassScopedExtensionContext = true) on Spring Framework 7.0, it will fail as it does on Spring Framework 6.2.x, since that annotation effectively reverts to the pre-7.0 semantics.

If you run your tests on Spring Framework 6.2.x (or any version prior to 7.0), you still have 2 distinct application contexts. The ApplicationContext for ChildTests is used when executing the test methods inherited from ParentTests; whereas, the ApplicationContext for ParentTests is used when executing the test methods in NestedTests. Consequently, the @MockitoBean field declared in ParentTests does not get reset after firstNestedTest(). The reason is that that field is sourced from the ApplicationContext for ChildTests instead of the current ApplicationContext for ParentTests.NestedTests. In other words, the current ApplicationContext does not contain the mocked ServiceB, and the MockitoResetTestExecutionListener therefore cannot reset it.

Luckily this particular scenario is no longer an issue with Spring Framework 7.0+ thanks to #35697.

However, the fact that you still have 2 distinct application contexts is undesirable and can lead to problems.

Specifically, Spring will never see the annotations on ChildTests (like @Import, etc.) when running test methods in NestedTests, since NestedTests is inherited from ParentTests.

As I explained in #35894 (comment):

This effectively boils down to an age old discrepancy between Spring and JUnit Jupiter: static vs. runtime enclosing types.

In light of the above, I am closing this as a duplicate of:

• Provide guidance on using @Nested within test classes with complex inheritance and annotation arrangements #28466

In particular, see #28466 (comment).