Disable mocks with an error message (#3424)
This allows us to avoid the memory leak issues addressed by `clearInlineMocks` and track how a mock object might leak from the test that instantiated it
Fixes #3419
diff --git a/src/main/java/org/mockito/MockitoFramework.java b/src/main/java/org/mockito/MockitoFramework.java
index 020186f..bf3843b 100644
--- a/src/main/java/org/mockito/MockitoFramework.java
+++ b/src/main/java/org/mockito/MockitoFramework.java
@@ -4,6 +4,7 @@
*/
package org.mockito;
+import org.mockito.exceptions.misusing.DisabledMockException;
import org.mockito.exceptions.misusing.RedundantListenerException;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.InvocationFactory;
@@ -90,7 +91,9 @@
InvocationFactory getInvocationFactory();
/**
- * Clears up internal state of all inline mocks.
+ * Clears up internal state of all inline mocks. Attempts to interact with mocks after this
+ * is called will throw {@link DisabledMockException}.
+ * <p>
* This method is only meaningful if inline mock maker is in use.
* For all other intents and purposes, this method is a no-op and need not be used.
* <p>
diff --git a/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java b/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java
new file mode 100644
index 0000000..d51bdfd
--- /dev/null
+++ b/src/main/java/org/mockito/exceptions/misusing/DisabledMockException.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.exceptions.misusing;
+
+import org.mockito.MockitoFramework;
+import org.mockito.exceptions.base.MockitoException;
+
+/**
+ * Thrown when a mock is accessed after it has been disabled by
+ * {@link MockitoFramework#clearInlineMocks()}.
+ */
+public class DisabledMockException extends MockitoException {
+ public DisabledMockException() {
+ super("Mock accessed after inline mocks were cleared");
+ }
+}
diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
index 74553b3..dc8eca3 100644
--- a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
+++ b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMaker.java
@@ -16,6 +16,7 @@
import org.mockito.internal.SuppressSignatureCheck;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.creation.instance.ConstructorInstantiator;
+import org.mockito.internal.framework.DisabledMockHandler;
import org.mockito.internal.util.Platform;
import org.mockito.internal.util.concurrent.DetachedThreadLocal;
import org.mockito.internal.util.concurrent.WeakConcurrentMap;
@@ -32,6 +33,7 @@
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.*;
+import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
import java.util.function.Function;
@@ -556,7 +558,11 @@
@Override
public void clearAllMocks() {
mockedStatics.getBackingMap().clear();
- mocks.clear();
+
+ for (Entry<Object, MockMethodInterceptor> entry : mocks) {
+ MockCreationSettings settings = entry.getValue().getMockHandler().getMockSettings();
+ entry.setValue(new MockMethodInterceptor(DisabledMockHandler.HANDLER, settings));
+ }
}
@Override
diff --git a/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java b/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java
new file mode 100644
index 0000000..c4fde91
--- /dev/null
+++ b/src/main/java/org/mockito/internal/framework/DisabledMockHandler.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.framework;
+
+import org.mockito.MockitoFramework;
+import org.mockito.exceptions.misusing.DisabledMockException;
+import org.mockito.invocation.Invocation;
+import org.mockito.invocation.InvocationContainer;
+import org.mockito.invocation.MockHandler;
+import org.mockito.mock.MockCreationSettings;
+
+/**
+ * Throws {@link DisabledMockException} when a mock is accessed after it has been disabled by
+ * {@link MockitoFramework#clearInlineMocks()}.
+ */
+public class DisabledMockHandler implements MockHandler {
+ public static MockHandler HANDLER = new DisabledMockHandler();
+
+ private DisabledMockHandler() {
+ // private, use HANDLER instead
+ }
+
+ @Override
+ public Object handle(Invocation invocation) {
+ throw new DisabledMockException();
+ }
+
+ @Override
+ public MockCreationSettings getMockSettings() {
+ return null;
+ }
+
+ @Override
+ public InvocationContainer getInvocationContainer() {
+ return null;
+ }
+}
diff --git a/src/main/java/org/mockito/plugins/InlineMockMaker.java b/src/main/java/org/mockito/plugins/InlineMockMaker.java
index 08fab59..6c3703c 100644
--- a/src/main/java/org/mockito/plugins/InlineMockMaker.java
+++ b/src/main/java/org/mockito/plugins/InlineMockMaker.java
@@ -5,6 +5,7 @@
package org.mockito.plugins;
import org.mockito.MockitoFramework;
+import org.mockito.exceptions.misusing.DisabledMockException;
/**
* Extension to {@link MockMaker} for mock makers that changes inline method implementations
@@ -37,8 +38,8 @@
void clearMock(Object mock);
/**
- * Cleans up internal state for all existing mocks. You may assume there won't be any interaction to mocks created
- * previously after this is called.
+ * Cleans up internal state for all existing mocks. Attempts to interact with mocks after this
+ * is called will throw {@link DisabledMockException}
*
* @since 2.25.0
*/
diff --git a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
index dc341d8..3a0e330 100644
--- a/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
+++ b/src/test/java/org/mockito/internal/creation/bytebuddy/InlineDelegateByteBuddyMockMakerTest.java
@@ -27,6 +27,7 @@
import org.mockito.internal.creation.MockSettingsImpl;
import org.mockito.internal.creation.bytebuddy.sample.DifferentPackage;
import org.mockito.internal.creation.settings.CreationSettings;
+import org.mockito.internal.framework.DisabledMockHandler;
import org.mockito.internal.handler.MockHandlerImpl;
import org.mockito.internal.stubbing.answers.Returns;
import org.mockito.internal.util.collections.Sets;
@@ -498,7 +499,7 @@
}
@Test
- public void test_clear_all_mock_clears_handler() {
+ public void test_clear_all_mock_assigns_disabled_handler() {
MockCreationSettings<GenericSubClass> settings = settingsFor(GenericSubClass.class);
GenericSubClass proxy1 =
mockMaker.createMock(settings, new MockHandlerImpl<GenericSubClass>(settings));
@@ -513,8 +514,8 @@
mockMaker.clearAllMocks();
// then
- assertThat(mockMaker.getHandler(proxy1)).isNull();
- assertThat(mockMaker.getHandler(proxy2)).isNull();
+ assertThat(mockMaker.getHandler(proxy1)).isEqualTo(DisabledMockHandler.HANDLER);
+ assertThat(mockMaker.getHandler(proxy2)).isEqualTo(DisabledMockHandler.HANDLER);
}
protected static <T> MockCreationSettings<T> settingsFor(
diff --git a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
index 3b2884e..756f75a 100644
--- a/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
+++ b/src/test/java/org/mockito/internal/framework/DefaultMockitoFrameworkTest.java
@@ -5,15 +5,18 @@
package org.mockito.internal.framework;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
import static org.mockito.Mockito.mockingDetails;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
import static org.mockito.Mockito.withSettings;
import static org.mockitoutil.ThrowableAssert.assertThat;
@@ -21,10 +24,14 @@
import java.util.Set;
import org.junit.After;
+import org.junit.Assert;
import org.junit.Test;
+import org.junit.platform.commons.util.Preconditions;
import org.mockito.ArgumentMatchers;
import org.mockito.MockSettings;
+import org.mockito.MockedStatic;
import org.mockito.StateMaster;
+import org.mockito.exceptions.misusing.DisabledMockException;
import org.mockito.exceptions.misusing.RedundantListenerException;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.listeners.MockCreationListener;
@@ -33,6 +40,24 @@
import org.mockito.plugins.InlineMockMaker;
import org.mockitoutil.TestBase;
+class PersonWithName {
+ private final String myName;
+
+ PersonWithName(String name) {
+ myName = Preconditions.notNull(name, "non-null name");
+ }
+
+ public String getMyName() {
+ return myName.toUpperCase();
+ }
+}
+
+class HasStatic {
+ public static String staticName() {
+ return "static name";
+ }
+}
+
public class DefaultMockitoFrameworkTest extends TestBase {
private DefaultMockitoFramework framework = new DefaultMockitoFramework();
@@ -149,22 +174,40 @@
}
@Test
- public void clears_all_mocks() {
+ public void behavior_after_clear_inline_mocks() {
// clearing mocks only works with inline mocking
assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
- // given
- List list1 = mock(List.class);
- assertTrue(mockingDetails(list1).isMock());
- List list2 = mock(List.class);
- assertTrue(mockingDetails(list2).isMock());
+ PersonWithName obj = mock(PersonWithName.class);
+ when(obj.getMyName()).thenReturn("Bob");
+ assertEquals("Bob", obj.getMyName());
+ assertTrue(mockingDetails(obj).isMock());
- // when
framework.clearInlineMocks();
- // then
- assertFalse(mockingDetails(list1).isMock());
- assertFalse(mockingDetails(list2).isMock());
+ try {
+ obj.getMyName();
+ } catch (DisabledMockException e) {
+ return;
+ }
+ Assert.fail("Should have thrown DisabledMockException");
+ }
+
+ @Test
+ public void clear_inline_mocks_clears_static_mocks() {
+ // disabling mocks only works with inline mocking
+ assumeTrue(Plugins.getMockMaker() instanceof InlineMockMaker);
+ assertEquals("static name", HasStatic.staticName());
+
+ // create a static mock
+ MockedStatic<HasStatic> mocked = mockStatic(HasStatic.class);
+
+ mocked.when(HasStatic::staticName).thenReturn("hacked name");
+ assertEquals("hacked name", HasStatic.staticName());
+
+ framework.clearInlineMocks();
+
+ assertEquals("static name", HasStatic.staticName());
}
@Test
