Refactor PowerMockito recipes for clarity and single responsibility (#943)

* Refactor PowerMockitoMockStaticToMockito for clarity and single responsibility

Extract independent responsibilities from the monolithic 557-line recipe:

- Extract `RemovePowerMockClassExtensions` recipe for removing
  `extends PowerMockConfiguration` and `extends PowerMockTestCase`
- Fold `@RunWith(PowerMockRunner.class)` removal (with and without
  delegate) into `PowerMockRunnerDelegateToRunWith`
- Replace 8 mutable instance fields with a `TestFramework` enum
- Add early returns throughout to reduce nesting and improve readability

* Clean up PowerMockitoMockStaticToMockito visitor

- Consolidate isStaticMockAlreadyClosed/isStaticMockAlreadyOpened into
  single hasMatchingInvocation method parameterized by MethodMatcher
- Restructure visitMethodInvocation with early returns for clarity
- Fix double getTestGroupsAsString() call in maybeAddTearDownMethodBody
- Simplify mockStatic tracking to use direct list access instead of
  Optional stream

* Improve PowerMockRunnerDelegateToRunWith per review feedback

- Use service(AnnotationService.class) instead of manual stream check
- Extract findDelegateRunnerArg method to avoid finalDelegateRunnerArg
- Move shared maybeRemoveImport(POWER_MOCK_RUNNER) above if/else so
  each branch can return immediately

* Move import removal before withLeadingAnnotations for immediate returns

* Update src/main/java/org/openrewrite/java/testing/mockito/PowerMockRunnerDelegateToRunWith.java

Author: timtebeek

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

@@ -16,6 +16,7 @@
 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;
@@ -24,6 +25,7 @@
 import org.openrewrite.java.AnnotationMatcher;
 import org.openrewrite.java.JavaIsoVisitor;
 import org.openrewrite.java.search.UsesType;
+import org.openrewrite.java.service.AnnotationService;
 import org.openrewrite.java.tree.Expression;
 import org.openrewrite.java.tree.J;
 
@@ -40,58 +42,72 @@ public class PowerMockRunnerDelegateToRunWith extends Recipe {
             new AnnotationMatcher("@org.junit.runner.RunWith(" + POWER_MOCK_RUNNER + ".class)");
 
     @Getter
-    final String displayName = "Replace `@PowerMockRunnerDelegate` with `@RunWith`";
+    final String displayName = "Replace PowerMock runner with JUnit `@RunWith`";
 
     @Getter
-    final String description = "Replaces `@PowerMockRunnerDelegate(X.class)` by promoting the delegate runner " +
-            "to `@RunWith(X.class)` and removing the PowerMock-specific annotation.";
+    final String description = "Replaces `@RunWith(PowerMockRunner.class)`. If `@PowerMockRunnerDelegate(X.class)` " +
+            "is present, promotes the delegate runner to `@RunWith(X.class)`. Otherwise, removes the " +
+            "`@RunWith(PowerMockRunner.class)` annotation entirely.";
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
         return Preconditions.check(
-                new UsesType<>(POWER_MOCK_RUNNER_DELEGATE, false),
+                Preconditions.or(
+                        new UsesType<>(POWER_MOCK_RUNNER_DELEGATE, false),
+                        new UsesType<>(POWER_MOCK_RUNNER, false)
+                ),
                 new JavaIsoVisitor<ExecutionContext>() {
                     @Override
                     public J.ClassDeclaration visitClassDeclaration(J.ClassDeclaration classDecl, ExecutionContext ctx) {
                         J.ClassDeclaration cd = super.visitClassDeclaration(classDecl, ctx);
 
-                        // Find @PowerMockRunnerDelegate and extract its argument
-                        Expression delegateRunnerArg = null;
-                        for (J.Annotation annotation : cd.getLeadingAnnotations()) {
-                            if (DELEGATE_MATCHER.matches(annotation)) {
-                                List<Expression> args = annotation.getArguments();
-                                if (args != null && !args.isEmpty()) {
-                                    delegateRunnerArg = args.get(0);
-                                    // Handle value = X.class form
-                                    if (delegateRunnerArg instanceof J.Assignment) {
-                                        delegateRunnerArg = ((J.Assignment) delegateRunnerArg).getAssignment();
-                                    }
-                                }
-                                break;
-                            }
+                        if (!service(AnnotationService.class).matches(getCursor(), RUN_WITH_POWER_MOCK_RUNNER_MATCHER)) {
+                            return cd;
                         }
 
-                        if (delegateRunnerArg == null) {
-                            return cd;
+                        maybeRemoveImport(POWER_MOCK_RUNNER);
+
+                        Expression delegateRunnerArg = findDelegateRunnerArg(cd);
+                        if (delegateRunnerArg != null) {
+                            // Replace @RunWith(PowerMockRunner.class) argument with the delegate runner,
+                            // and remove @PowerMockRunnerDelegate
+                            maybeRemoveImport(POWER_MOCK_RUNNER_DELEGATE);
+                            return cd.withLeadingAnnotations(ListUtils.map(cd.getLeadingAnnotations(), annotation -> {
+                                if (RUN_WITH_POWER_MOCK_RUNNER_MATCHER.matches(annotation)) {
+                                    return annotation.withArguments(Collections.singletonList(delegateRunnerArg));
+                                }
+                                if (DELEGATE_MATCHER.matches(annotation)) {
+                                    return null;
+                                }
+                                return annotation;
+                            }));
                         }
 
-                        // Replace @RunWith(PowerMockRunner.class) argument with the delegate runner,
-                        // and remove @PowerMockRunnerDelegate
-                        final Expression finalDelegateRunnerArg = delegateRunnerArg;
-                        cd = cd.withLeadingAnnotations(ListUtils.map(cd.getLeadingAnnotations(), annotation -> {
+                        // No delegate — just remove @RunWith(PowerMockRunner.class)
+                        maybeRemoveImport("org.junit.runner.RunWith");
+                        return cd.withLeadingAnnotations(ListUtils.map(cd.getLeadingAnnotations(), annotation -> {
                             if (RUN_WITH_POWER_MOCK_RUNNER_MATCHER.matches(annotation)) {
-                                return annotation.withArguments(Collections.singletonList(finalDelegateRunnerArg));
-                            }
-                            if (DELEGATE_MATCHER.matches(annotation)) {
                                 return null;
                             }
                             return annotation;
                         }));
+                    }
 
-                        maybeRemoveImport(POWER_MOCK_RUNNER_DELEGATE);
-                        maybeRemoveImport(POWER_MOCK_RUNNER);
-
-                        return cd;
+                    private @Nullable Expression findDelegateRunnerArg(J.ClassDeclaration cd) {
+                        for (J.Annotation annotation : cd.getLeadingAnnotations()) {
+                            if (DELEGATE_MATCHER.matches(annotation)) {
+                                List<Expression> args = annotation.getArguments();
+                                if (args != null && !args.isEmpty()) {
+                                    Expression arg = args.get(0);
+                                    if (arg instanceof J.Assignment) {
+                                        return ((J.Assignment) arg).getAssignment();
+                                    }
+                                    return arg;
+                                }
+                                return null;
+                            }
+                        }
+                        return null;
                     }
                 }
         );