Add support for static mocks on DoNotMockEnforcer (#3220)

Fixes #3219
mockito · Jan 22, 2024 · 9173522 · 9173522
1 parent a021436
commit 9173522
Show file tree

Hide file tree

Showing 15 changed files with 346 additions and 67 deletions.
diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
@@ -26,10 +26,7 @@
 import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
 
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Function;
 
 import org.mockito.InOrder;
@@ -59,7 +56,7 @@
 import org.mockito.invocation.Invocation;
 import org.mockito.invocation.MockHandler;
 import org.mockito.mock.MockCreationSettings;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.MockMaker;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.LenientStubber;
@@ -70,9 +67,8 @@
 @SuppressWarnings("unchecked")
 public class MockitoCore {
 
-    private static final DoNotMockEnforcer DO_NOT_MOCK_ENFORCER = Plugins.getDoNotMockEnforcer();
-    private static final Set<Class<?>> MOCKABLE_CLASSES =
-            Collections.synchronizedSet(new HashSet<>());
+    private static final DoNotMockEnforcerWithType DO_NOT_MOCK_ENFORCER =
+            Plugins.getDoNotMockEnforcer();
 
     public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         if (!(settings instanceof MockSettingsImpl)) {
@@ -84,43 +80,12 @@ public <T> T mock(Class<T> typeToMock, MockSettings settings) {
         }
         MockSettingsImpl impl = (MockSettingsImpl) settings;
         MockCreationSettings<T> creationSettings = impl.build(typeToMock);
-        checkDoNotMockAnnotation(creationSettings.getTypeToMock(), creationSettings);
+        checkDoNotMockAnnotation(creationSettings);
         T mock = createMock(creationSettings);
         mockingProgress().mockingStarted(mock, creationSettings);
         return mock;
     }
 
-    private void checkDoNotMockAnnotation(
-            Class<?> typeToMock, MockCreationSettings<?> creationSettings) {
-        checkDoNotMockAnnotationForType(typeToMock);
-        for (Class<?> aClass : creationSettings.getExtraInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-    }
-
-    private static void checkDoNotMockAnnotationForType(Class<?> type) {
-        // Object and interfaces do not have a super class
-        if (type == null) {
-            return;
-        }
-
-        if (MOCKABLE_CLASSES.contains(type)) {
-            return;
-        }
-
-        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(type);
-        if (warning != null) {
-            throw new DoNotMockException(warning);
-        }
-
-        checkDoNotMockAnnotationForType(type.getSuperclass());
-        for (Class<?> aClass : type.getInterfaces()) {
-            checkDoNotMockAnnotationForType(aClass);
-        }
-
-        MOCKABLE_CLASSES.add(type);
-    }
-
     public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings settings) {
         if (!MockSettingsImpl.class.isInstance(settings)) {
             throw new IllegalArgumentException(
@@ -131,12 +96,20 @@ public <T> MockedStatic<T> mockStatic(Class<T> classToMock, MockSettings setting
         }
         MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
         MockCreationSettings<T> creationSettings = impl.buildStatic(classToMock);
+        checkDoNotMockAnnotation(creationSettings);
         MockMaker.StaticMockControl<T> control = createStaticMock(classToMock, creationSettings);
         control.enable();
         mockingProgress().mockingStarted(classToMock, creationSettings);
         return new MockedStaticImpl<>(control);
     }
 
+    private void checkDoNotMockAnnotation(MockCreationSettings<?> creationSettings) {
+        String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(creationSettings);
+        if (warning != null) {
+            throw new DoNotMockException(warning);
+        }
+    }
+
     public <T> MockedConstruction<T> mockConstruction(
             Class<T> typeToMock,
             Function<MockedConstruction.Context, ? extends MockSettings> settingsFactory,

diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -12,7 +12,7 @@
 import org.mockito.MockMakers;
 import org.mockito.internal.util.MockUtil;
 import org.mockito.plugins.AnnotationEngine;
-import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -62,7 +62,7 @@ public class DefaultMockitoPlugins implements MockitoPlugins {
         DEFAULT_PLUGINS.put(
                 REFLECTION_ALIAS, "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
         DEFAULT_PLUGINS.put(
-                DoNotMockEnforcer.class.getName(),
+                DoNotMockEnforcerWithType.class.getName(),
                 "org.mockito.internal.configuration.DefaultDoNotMockEnforcer");
 
         MOCK_MAKER_ALIASES.add(INLINE_ALIAS);

diff --git a/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java b/src/main/java/org/mockito/internal/configuration/plugins/PluginRegistry.java
@@ -5,8 +5,10 @@
 package org.mockito.internal.configuration.plugins;
 
 import java.util.List;
+
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -46,8 +48,10 @@ class PluginRegistry {
     private final List<MockResolver> mockResolvers =
             new PluginLoader(pluginSwitch).loadPlugins(MockResolver.class);
 
-    private final DoNotMockEnforcer doNotMockEnforcer =
-            new PluginLoader(pluginSwitch).loadPlugin(DoNotMockEnforcer.class);
+    private final DoNotMockEnforcerWithType doNotMockEnforcer =
+            (DoNotMockEnforcerWithType)
+                    (new PluginLoader(pluginSwitch)
+                            .loadPlugin(DoNotMockEnforcerWithType.class, DoNotMockEnforcer.class));
 
     PluginRegistry() {
         instantiatorProvider =
@@ -119,7 +123,7 @@ MockitoLogger getMockitoLogger() {
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
      * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
      */
-    DoNotMockEnforcer getDoNotMockEnforcer() {
+    DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return doNotMockEnforcer;
     }
 

diff --git a/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java b/src/main/java/org/mockito/internal/configuration/plugins/Plugins.java
@@ -4,10 +4,12 @@
  */
 package org.mockito.internal.configuration.plugins;
 
-import org.mockito.DoNotMock;
 import java.util.List;
+
+import org.mockito.DoNotMock;
 import org.mockito.plugins.AnnotationEngine;
 import org.mockito.plugins.DoNotMockEnforcer;
+import org.mockito.plugins.DoNotMockEnforcerWithType;
 import org.mockito.plugins.InstantiatorProvider2;
 import org.mockito.plugins.MemberAccessor;
 import org.mockito.plugins.MockMaker;
@@ -16,7 +18,9 @@
 import org.mockito.plugins.MockitoPlugins;
 import org.mockito.plugins.StackTraceCleanerProvider;
 
-/** Access to Mockito behavior that can be reconfigured by plugins */
+/**
+ * Access to Mockito behavior that can be reconfigured by plugins
+ */
 public final class Plugins {
 
     private static final PluginRegistry registry = new PluginRegistry();
@@ -99,9 +103,10 @@ public static MockitoPlugins getPlugins() {
      * Returns the {@link DoNotMock} enforcer available for the current runtime.
      *
      * <p> Returns {@link org.mockito.internal.configuration.DefaultDoNotMockEnforcer} if no
-     * {@link DoNotMockEnforcer} extension exists or is visible in the current classpath.</p>
+     * {@link DoNotMockEnforcerWithType} or {@link DoNotMockEnforcer} extension exists or is visible
+     * in the current classpath.</p>
      */
-    public static DoNotMockEnforcer getDoNotMockEnforcer() {
+    public static DoNotMockEnforcerWithType getDoNotMockEnforcer() {
         return registry.getDoNotMockEnforcer();
     }
 

diff --git a/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java b/src/main/java/org/mockito/internal/creation/MockSettingsImpl.java
@@ -34,6 +34,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -283,9 +284,7 @@ private static <T> CreationSettings<T> validatedSettings(
         // TODO SF - I don't think we really need CreationSettings type
         // TODO do we really need to copy the entire settings every time we create mock object? it
         // does not seem necessary.
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), typeToMock, false));
-        settings.setTypeToMock(typeToMock);
+        CreationSettings<T> settings = buildCreationSettings(typeToMock, source, MockType.INSTANCE);
         settings.setExtraInterfaces(prepareExtraInterfaces(source));
         return settings;
     }
@@ -306,9 +305,15 @@ private static <T> CreationSettings<T> validatedStaticSettings(
                     "Cannot specify spied instance for static mock of " + classToMock);
         }
 
-        CreationSettings<T> settings = new CreationSettings<T>(source);
-        settings.setMockName(new MockNameImpl(source.getName(), classToMock, true));
+        return buildCreationSettings(classToMock, source, MockType.STATIC);
+    }
+
+    private static <T> CreationSettings<T> buildCreationSettings(
+            Class<T> classToMock, CreationSettings<T> source, MockType mockType) {
+        CreationSettings<T> settings = new CreationSettings<>(source);
+        settings.setMockName(new MockNameImpl(source.getName(), classToMock, mockType));
         settings.setTypeToMock(classToMock);
+        settings.setMockType(mockType);
         return settings;
     }
 

diff --git a/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java b/src/main/java/org/mockito/internal/creation/settings/CreationSettings.java
@@ -18,6 +18,7 @@
 import org.mockito.listeners.VerificationStartedListener;
 import org.mockito.mock.MockCreationSettings;
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 import org.mockito.mock.SerializableMode;
 import org.mockito.quality.Strictness;
 import org.mockito.stubbing.Answer;
@@ -49,6 +50,7 @@ public class CreationSettings<T> implements MockCreationSettings<T>, Serializabl
     private Object[] constructorArgs;
     protected Strictness strictness = null;
     protected String mockMaker;
+    protected MockType mockType;
 
     public CreationSettings() {}
 
@@ -73,6 +75,7 @@ public CreationSettings(CreationSettings copy) {
         this.strictness = copy.strictness;
         this.stripAnnotations = copy.stripAnnotations;
         this.mockMaker = copy.mockMaker;
+        this.mockType = copy.mockType;
     }
 
     @Override
@@ -198,4 +201,13 @@ public String getMockMaker() {
     public Type getGenericTypeToMock() {
         return genericTypeToMock;
     }
+
+    @Override
+    public MockType getMockType() {
+        return mockType;
+    }
+
+    public void setMockType(MockType mockType) {
+        this.mockType = mockType;
+    }
 }
diff --git a/src/main/java/org/mockito/internal/util/MockNameImpl.java b/src/main/java/org/mockito/internal/util/MockNameImpl.java
@@ -7,6 +7,7 @@
 import java.io.Serializable;
 
 import org.mockito.mock.MockName;
+import org.mockito.mock.MockType;
 
 public class MockNameImpl implements MockName, Serializable {
 
@@ -15,9 +16,9 @@ public class MockNameImpl implements MockName, Serializable {
     private boolean defaultName;
 
     @SuppressWarnings("unchecked")
-    public MockNameImpl(String mockName, Class<?> type, boolean mockedStatic) {
+    public MockNameImpl(String mockName, Class<?> type, MockType mockType) {
         if (mockName == null) {
-            this.mockName = mockedStatic ? toClassName(type) : toInstanceName(type);
+            this.mockName = mockType == MockType.STATIC ? toClassName(type) : toInstanceName(type);
             this.defaultName = true;
         } else {
             this.mockName = mockName;

diff --git a/src/main/java/org/mockito/mock/MockCreationSettings.java b/src/main/java/org/mockito/mock/MockCreationSettings.java
@@ -151,4 +151,12 @@ public interface MockCreationSettings<T> {
      * @since 4.8.0
      */
     String getMockMaker();
+
+    /**
+     * Returns the {@link MockType} for the mock being created.
+     *
+     * @see MockType
+     * @since 5.9.0
+     */
+    MockType getMockType();
 }
diff --git a/src/main/java/org/mockito/mock/MockType.java b/src/main/java/org/mockito/mock/MockType.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.mock;
+
+/**
+ * The type of mock being created
+ */
+public enum MockType {
+
+    /**
+     * Mock created as an instance of the mocked type
+     */
+    INSTANCE,
+
+    /**
+     * Mock replaces the mocked type through static mocking
+     */
+    STATIC,
+}