Add RemoveDoNothingForDefaultMocks recipe (#947)

* Add RemoveDoNothingForDefaultMocks recipe (#946)

Remove unnecessary `doNothing()` stubbings on `@Mock` fields that cause
UnnecessaryStubbingException after migrating to Mockito 3+.

* Remove redundant `false` from MethodMatcher constructors

`false` is the default for `matchOverrides`, so the single-arg
constructor is sufficient and consistent with the rest of the codebase.

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: bmuschko

src/main/java/org/openrewrite/java/testing/mockito/RemoveDoNothingForDefaultMocks.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * 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.openrewrite.java.testing.mockito;
+
+import lombok.Getter;
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.Preconditions;
+import org.openrewrite.Recipe;
+import org.openrewrite.TreeVisitor;
+import org.openrewrite.java.AnnotationMatcher;
+import org.openrewrite.java.JavaIsoVisitor;
+import org.openrewrite.java.MethodMatcher;
+import org.openrewrite.java.search.UsesMethod;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.Statement;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class RemoveDoNothingForDefaultMocks extends Recipe {
+
+    @Getter
+    final String displayName = "Remove `doNothing()` for void methods on `@Mock` fields";
+
+    @Getter
+    final String description = "Remove unnecessary `doNothing()` stubbings for void methods on `@Mock` fields. " +
+            "Mockito mocks already do nothing for void methods by default, making these stubbings redundant " +
+            "and triggering strict stubbing violations in Mockito 3+.";
+
+    private static final MethodMatcher DO_NOTHING_MATCHER = new MethodMatcher("org.mockito.Mockito doNothing()");
+    private static final MethodMatcher STUBBER_WHEN_MATCHER = new MethodMatcher("org.mockito.stubbing.Stubber when(..)");
+    private static final AnnotationMatcher MOCK_ANNOTATION_MATCHER = new AnnotationMatcher("@org.mockito.Mock");
+
+    @Override
+    public TreeVisitor<?, ExecutionContext> getVisitor() {
+        return Preconditions.check(
+                new UsesMethod<>(DO_NOTHING_MATCHER),
+                new JavaIsoVisitor<ExecutionContext>() {
+                    @Override
+                    public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
+                        Set<String> mockFieldNames = new HashSet<>();
+                        for (Statement stmt : classDecl.getBody().getStatements()) {
+                            if (stmt instanceof J.VariableDeclarations) {
+                                J.VariableDeclarations vd = (J.VariableDeclarations) stmt;
+                                if (vd.getLeadingAnnotations().stream().anyMatch(MOCK_ANNOTATION_MATCHER::matches)) {
+                                    for (J.VariableDeclarations.NamedVariable var : vd.getVariables()) {
+                                        mockFieldNames.add(var.getSimpleName());
+                                    }
+                                }
+                            }
+                        }
+                        getCursor().putMessage("mockFieldNames", mockFieldNames);
+                        return super.visitClassDeclaration(classDecl, ctx);
+                    }
+
+                    @Override
+                    public J.@Nullable MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
+                        J.MethodInvocation mi = super.visitMethodInvocation(method, ctx);
+                        if (mi != null && isDoNothingOnMockField(mi)) {
+                            maybeRemoveImport("org.mockito.Mockito.doNothing");
+                            return null;
+                        }
+                        return mi;
+                    }
+
+                    private boolean isDoNothingOnMockField(J.MethodInvocation mi) {
+                        // Pattern: doNothing().when(mock).someVoidMethod(args)
+                        if (!(mi.getSelect() instanceof J.MethodInvocation)) {
+                            return false;
+                        }
+                        J.MethodInvocation whenCall = (J.MethodInvocation) mi.getSelect();
+                        if (!STUBBER_WHEN_MATCHER.matches(whenCall)) {
+                            return false;
+                        }
+                        // Ensure doNothing() is standalone (not chained after doThrow() etc.)
+                        if (!(whenCall.getSelect() instanceof J.MethodInvocation)) {
+                            return false;
+                        }
+                        J.MethodInvocation doNothingCall = (J.MethodInvocation) whenCall.getSelect();
+                        if (!DO_NOTHING_MATCHER.matches(doNothingCall) || doNothingCall.getSelect() != null) {
+                            return false;
+                        }
+                        // Check that the when() argument references a @Mock field
+                        if (whenCall.getArguments().isEmpty() || !(whenCall.getArguments().get(0) instanceof J.Identifier)) {
+                            return false;
+                        }
+                        String mockName = ((J.Identifier) whenCall.getArguments().get(0)).getSimpleName();
+                        Set<String> mockFieldNames = getCursor().getNearestMessage("mockFieldNames");
+                        return mockFieldNames != null && mockFieldNames.contains(mockName);
+                    }
+                }
+        );
+    }
+}

src/main/resources/META-INF/rewrite/mockito.yml

@@ -29,6 +29,7 @@ recipeList:
   - org.openrewrite.java.RemoveAnnotation:
       annotationPattern: "@org.mockito.junit.jupiter.MockitoSettings(strictness=org.mockito.quality.Strictness.WARN)"
   - org.openrewrite.java.testing.mockito.RemoveTimesZeroAndOne
+  - org.openrewrite.java.testing.mockito.RemoveDoNothingForDefaultMocks
   - org.openrewrite.java.testing.mockito.SimplifyMockitoVerifyWhenGiven
   - org.openrewrite.java.testing.mockito.MockConstructionToTryWithResources
 ---

src/main/resources/META-INF/rewrite/recipes.csv

@@ -200,6 +200,7 @@ maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.tes
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.PowerMockitoWhenNewToMockito,Replace `PowerMockito.whenNew` with Mockito counterpart,Replaces `PowerMockito.whenNew` calls with respective `Mockito.whenConstructed` calls.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.RemoveInitMocksIfRunnersSpecified,Remove `MockitoAnnotations.initMocks(this)` and `openMocks(this)` if JUnit runners specified,Remove `MockitoAnnotations.initMocks(this)` and `MockitoAnnotations.openMocks(this)` if class-level JUnit runners `@RunWith(MockitoJUnitRunner.class)` or `@ExtendWith(MockitoExtension.class)` are specified. These manual initialization calls are redundant when using Mockito's JUnit integration.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.RemovePowerMockClassExtensions,Remove PowerMock class extensions,"Removes `extends PowerMockConfiguration` and `extends PowerMockTestCase` from test classes, as these are PowerMock-specific base classes not needed with Mockito.",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
+maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.RemoveDoNothingForDefaultMocks,Remove `doNothing()` for void methods on `@Mock` fields,Remove unnecessary `doNothing()` stubbings for void methods on `@Mock` fields. Mockito mocks already do nothing for void methods by default making these stubbings redundant and triggering strict stubbing violations in Mockito 3+.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.RemoveTimesZeroAndOne,Remove `Mockito.times(0)` and `Mockito.times(1)`,Remove `Mockito.times(0)` and `Mockito.times(1)` from `Mockito.verify()` calls.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.ReplaceInitMockToOpenMock,Replace `MockitoAnnotations.initMocks(this)` to `MockitoAnnotations.openMocks(this)`,Replace `MockitoAnnotations.initMocks(this)` to `MockitoAnnotations.openMocks(this)` and generate `AutoCloseable` mocks.,1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,,
 maven,org.openrewrite.recipe:rewrite-testing-frameworks,org.openrewrite.java.testing.mockito.ReplaceMockitoTestExecutionListener,Replace `MockitoTestExecutionListener` with the equivalent Mockito test initialization,"Replace `@TestExecutionListeners(MockitoTestExecutionListener.class)` with the appropriate Mockito initialization for the test framework in use: `@ExtendWith(MockitoExtension.class)` for JUnit 5, `@RunWith(MockitoJUnitRunner.class)` for JUnit 4, or `MockitoAnnotations.openMocks(this)` for TestNG.",1,Mockito,Testing,Java,,,Basic building blocks for transforming Java code.,"[{""name"":""targetFramework"",""type"":""String"",""displayName"":""Target framework"",""description"":""The test framework to use when imports alone cannot determine the framework. Typically set by wrapper recipes that check project dependencies."",""valid"":[""jupiter"",""junit4"",""testng""]}]",