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/main/java/org/springframework/test/context/bean/override/mockito/MockitoSpyBeanOverrideHandler.java

@@ -30,7 +30,6 @@ import org.springframework.core.ResolvableType;
 import org.springframework.lang.Nullable;
 import org.springframework.test.context.bean.override.BeanOverrideHandler;
 import org.springframework.test.context.bean.override.BeanOverrideStrategy;
-import org.springframework.test.util.AopTestUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -103,7 +102,7 @@ class MockitoSpyBeanOverrideHandler extends AbstractMockitoBeanOverrideHandler {
 
 		@Override
 		public void onVerificationStarted(VerificationStartedEvent event) {
-			event.setMock(AopTestUtils.getUltimateTargetObject(event.getMock()));
+			event.setMock(SpringMockResolver.getUltimateTargetObject(event.getMock()));
 		}
 	}
 

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2012-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.mockito.plugins.MockResolver;
+
+import org.springframework.aop.TargetSource;
+import org.springframework.aop.framework.Advised;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.util.Assert;
+
+/**
+ * A {@link MockResolver} for testing Spring applications with Mockito.
+ *
+ * <p>Resolves mocks by walking the Spring AOP proxy chain until the target or a
+ * non-static proxy is found.
+ *
+ * @author Sam Brannen
+ * @author Andy Wilkinson
+ * @since 6.2
+ */
+public class SpringMockResolver implements MockResolver {
+
+	@Override
+	public Object resolve(Object instance) {
+		return getUltimateTargetObject(instance);
+	}
+
+	/**
+	 * This is a modified version of
+	 * {@link org.springframework.test.util.AopTestUtils#getUltimateTargetObject(Object)
+	 * AopTestUtils#getUltimateTargetObject()} which only checks static target
+	 * sources.
+	 * @param <T> the type of the target object
+	 * @param candidate the instance to check (potentially a Spring AOP proxy;
+	 * never {@code null})
+	 * @return the target object or the {@code candidate} (never {@code null})
+	 * @throws IllegalStateException if an error occurs while unwrapping a proxy
+	 * @see Advised#getTargetSource()
+	 * @see TargetSource#isStatic()
+	 */
+	@SuppressWarnings("unchecked")
+	static <T> T getUltimateTargetObject(Object candidate) {
+		Assert.notNull(candidate, "Candidate must not be null");
+		try {
+			if (AopUtils.isAopProxy(candidate) && candidate instanceof Advised advised) {
+				TargetSource targetSource = advised.getTargetSource();
+				if (targetSource.isStatic()) {
+					Object target = targetSource.getTarget();
+					if (target != null) {
+						return getUltimateTargetObject(target);
+					}
+				}
+			}
+		}
+		catch (Throwable ex) {
+			throw new IllegalStateException("Failed to unwrap proxied object", ex);
+		}
+		return (T) candidate;
+	}
+
+}