Support transparent verification for @⁠MockitoSpyBean

Prior to this commit, SpringAopBypassingVerificationStartedListener
provided partial support for transparent verification for Mockito spies
created via @⁠MockitoSpyBean when the spy is wrapped in a Spring AOP
proxy. However, attempting to actually verify invocations for a spy
resulted in an exception from Mockito since MockUtil.isMock() returned
false in such scenarios.

This commit addresses that by introducing a SpringMockResolver that
resolves mocks by walking the Spring AOP proxy chain until the target
or a non-static proxy is found.

SpringMockResolver is automatically registered whenever the spring-test
JAR is on the classpath, allowing Mockito to transparently resolve mocks
wrapped in Spring AOP proxies.

Closes gh-33774

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

@@ -16,13 +16,15 @@
 
 package org.springframework.test.context.bean.override.mockito;
 
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.RepeatedTest;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mockito;
 
 import org.springframework.aop.support.AopUtils;
 import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.CacheEvict;
 import org.springframework.cache.annotation.Cacheable;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
@@ -58,12 +60,21 @@ class MockitoSpyBeanAndSpringAopProxyTests {
 	DateService dateService;
 
 
+	@BeforeEach
+	void resetCache() {
+		// We have to clear the "test" cache before each test. Otherwise, method
+		// invocations on the Spring AOP proxy will never make it to the Mockito spy.
+		dateService.clearCache();
+	}
+
 	/**
 	 * Stubbing and verification for a Mockito spy that is wrapped in a Spring AOP
 	 * proxy should always work when performed via the ultimate target of the Spring
 	 * AOP proxy (i.e., the actual spy instance).
 	 */
-	@Test
+	// We need to run this test at least twice to ensure the Mockito spy can be reused
+	// across test method invocations without using @DirtestContext.
+	@RepeatedTest(2)
 	void stubAndVerifyOnUltimateTargetOfSpringAopProxy() {
 		assertThat(AopUtils.isAopProxy(dateService)).as("is Spring AOP proxy").isTrue();
 		DateService spy = AopTestUtils.getUltimateTargetObject(dateService);
@@ -93,13 +104,14 @@ class MockitoSpyBeanAndSpringAopProxyTests {
 	 * AOP proxy to stubbing calls, while supplying the Spring AOP proxy to verification
 	 * calls.
 	 */
-	@Disabled("Disabled until transparent verification for @MockitoSpyBean is implemented")
-	@Test
+	// We need to run this test at least twice to ensure the Mockito spy can be reused
+	// across test method invocations without using @DirtestContext.
+	@RepeatedTest(2)
 	void stubOnUltimateTargetAndVerifyOnSpringAopProxy() {
 		assertThat(AopUtils.isAopProxy(dateService)).as("is Spring AOP proxy").isTrue();
-		DateService spy = AopTestUtils.getUltimateTargetObject(dateService);
-		assertThat(Mockito.mockingDetails(spy).isSpy()).as("ultimate target is Mockito spy").isTrue();
+		assertThat(Mockito.mockingDetails(dateService).isSpy()).as("Spring AOP proxy is Mockito spy").isTrue();
 
+		DateService spy = AopTestUtils.getUltimateTargetObject(dateService);
 		given(spy.getDate(false)).willReturn(1L);
 		Long date = dateService.getDate(false);
 		assertThat(date).isOne();
@@ -123,7 +135,9 @@ class MockitoSpyBeanAndSpringAopProxyTests {
 	 * stubbing for a proxied mock.
 	 */
 	@Disabled("Disabled until Mockito provides support for transparent stubbing of a proxied spy")
-	@Test
+	// We need to run this test at least twice to ensure the Mockito spy can be reused
+	// across test method invocations without using @DirtestContext.
+	@RepeatedTest(2)
 	void stubAndVerifyDirectlyOnSpringAopProxy() throws Exception {
 		assertThat(AopUtils.isCglibProxy(dateService)).as("is Spring AOP CGLIB proxy").isTrue();
 		assertThat(Mockito.mockingDetails(dateService).isSpy()).as("is Mockito spy").isTrue();
@@ -166,6 +180,11 @@ class MockitoSpyBeanAndSpringAopProxyTests {
 		Long getDate(boolean argument) {
 			return System.nanoTime();
 		}
+
+		@CacheEvict(cacheNames = "test", allEntries = true)
+		void clearCache() {
+		}
+
 	}
 
 }

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2002-2024 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.mockito;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.internal.configuration.plugins.Plugins;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for {@link SpringMockResolver}.
+ *
+ * @author Andy Wilkinson
+ * @since 6.2
+ * @see SpringMockResolverTests
+ */
+class SpringMockResolverIntegrationTests {
+
+	@Test
+	void customMockResolverIsRegisteredWithMockito() {
+		assertThat(Plugins.getMockResolvers()).hasOnlyElementsOfType(SpringMockResolver.class);
+	}
+
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2002-2024 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.mockito;
+
+import org.junit.jupiter.api.Test;
+
+import org.springframework.aop.SpringProxy;
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.aop.target.HotSwappableTargetSource;
+import org.springframework.aop.target.SingletonTargetSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for {@link SpringMockResolver}.
+ *
+ * @author Moritz Halbritter
+ * @author Sam Brannen
+ * @since 6.2
+ * @see SpringMockResolverIntegrationTests
+ */
+class SpringMockResolverTests {
+
+	@Test
+	void staticTarget() {
+		MyServiceImpl myService = new MyServiceImpl();
+		MyService proxy = ProxyFactory.getProxy(MyService.class, new SingletonTargetSource(myService));
+		Object target = new SpringMockResolver().resolve(proxy);
+		assertThat(target).isInstanceOf(MyServiceImpl.class);
+	}
+
+	@Test
+	void nonStaticTarget() {
+		MyServiceImpl myService = new MyServiceImpl();
+		MyService proxy = ProxyFactory.getProxy(MyService.class, new HotSwappableTargetSource(myService));
+		Object target = new SpringMockResolver().resolve(proxy);
+		assertThat(target).isInstanceOf(SpringProxy.class);
+	}
+
+
+	private interface MyService {
+	}
+
+	private static final class MyServiceImpl implements MyService {
+	}
+
+}