Add JMockit's MockUp to Mockito migration

build.gradle.kts

@@ -19,6 +19,7 @@ recipeDependencies {
     parserClasspath("com.github.tomakehurst:wiremock-jre8:2.35.0")
     parserClasspath("org.mockito:mockito-all:1.10.19")
     parserClasspath("org.mockito:mockito-core:3.+")
+    parserClasspath("org.mockito:mockito-core:5.+")
     parserClasspath("org.jmockit:jmockit:1.49")
     parserClasspath("org.jmockit:jmockit:1.22") // last version with NonStrictExpectations
     parserClasspath("org.mockito:mockito-junit-jupiter:3.+")

src/main/java/org/openrewrite/java/testing/jmockit/JMockitBlockType.java

@@ -20,6 +20,7 @@
 @Getter
 enum JMockitBlockType {
 
+    MockUp,
     Expectations,
     Verifications,
     NonStrictExpectations;

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2024 the original author or authors.
+ * <p>
+ * 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
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <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 org.jspecify.annotations.Nullable;
+import org.openrewrite.Cursor;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.java.AnnotationMatcher;
+import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.JavaTemplate;
+import org.openrewrite.java.JavaVisitor;
+import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.Statement;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class MockitoUtils {
+    public static J.ClassDeclaration maybeAddMethodWithAnnotation(
+      JavaVisitor visitor,
+      J.ClassDeclaration classDecl,
+      ExecutionContext ctx,
+      String methodName,
+      String methodAnnotationSignature,
+      String methodAnnotationToAdd,
+      String additionalClasspathResource,
+      String importToAdd,
+      String methodAnnotationParameters
+    ) {
+        if (hasMethodWithAnnotation(classDecl, new AnnotationMatcher(methodAnnotationSignature))) {
+            return classDecl;
+        }
+
+        J.MethodDeclaration firstTestMethod = getFirstTestMethod(
+          classDecl.getBody().getStatements().stream().filter(J.MethodDeclaration.class::isInstance)
+            .map(J.MethodDeclaration.class::cast).collect(Collectors.toList()));
+
+        visitor.maybeAddImport(importToAdd);
+        return JavaTemplate.builder(methodAnnotationToAdd + methodAnnotationParameters + " public void " + methodName + "() {}")
+          .contextSensitive()
+          .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, additionalClasspathResource))
+          .imports(importToAdd)
+          .build()
+          .apply(
+            new Cursor(visitor.getCursor().getParentOrThrow(), classDecl),
+            (firstTestMethod != null) ?
+              firstTestMethod.getCoordinates().before() :
+              classDecl.getBody().getCoordinates().lastStatement()
+          );
+    }
+
+    private static boolean hasMethodWithAnnotation(J.ClassDeclaration classDecl, AnnotationMatcher annotationMatcher) {
+        for (Statement statement : classDecl.getBody().getStatements()) {
+            if (statement instanceof J.MethodDeclaration) {
+                J.MethodDeclaration methodDeclaration = (J.MethodDeclaration) statement;
+                List<J.Annotation> allAnnotations = methodDeclaration.getAllAnnotations();
+                for (J.Annotation annotation : allAnnotations) {
+                    if (annotationMatcher.matches(annotation)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private static J.@Nullable MethodDeclaration getFirstTestMethod(List<J.MethodDeclaration> methods) {
+        for (J.MethodDeclaration methodDeclaration : methods) {
+            for (J.Annotation annotation : methodDeclaration.getLeadingAnnotations()) {
+                if ("Test".equals(annotation.getSimpleName())) {
+                    return methodDeclaration;
+                }
+            }
+        }
+        return null;
+    }
+}

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

@@ -23,6 +23,7 @@ tags:
   - jmockit
 recipeList:
   - org.openrewrite.java.testing.jmockit.JMockitBlockToMockito
+  - org.openrewrite.java.testing.jmockit.JMockitMockUpToMockito
   - org.openrewrite.java.testing.jmockit.JMockitAnnotatedArgumentToMockito
   - org.openrewrite.java.ChangeType:
       oldFullyQualifiedTypeName: mockit.Mocked