HamcrestMatcherToAssertJ: isNull() and isNotNull() take no args (#864)

Correct migration to AssertJ's `isNull()` and `isNotNull()`.

Fixes: #862

Author: knutwannheden

src/main/java/org/openrewrite/java/testing/hamcrest/HamcrestMatcherToAssertJ.java

@@ -27,8 +27,7 @@
 import org.openrewrite.java.tree.*;
 import org.openrewrite.marker.Markers;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 import static java.util.stream.Collectors.joining;
 
@@ -77,6 +76,9 @@ private class MigrateToAssertJVisitor extends JavaIsoVisitor<ExecutionContext> {
         private final MethodMatcher matchersMatcher = new MethodMatcher("org.hamcrest.*Matchers " + matcher + "(..)");
         private final MethodMatcher subMatcher = new MethodMatcher("org.hamcrest.*Matchers *(org.hamcrest.Matcher)");
 
+        // AssertJ assertions that don't take any arguments - matcher arguments should be ignored
+        private final Set<String> noArgAssertions = new HashSet<>(Arrays.asList("isNotNull", "isNull"));
+
         @Override
         public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
             J.MethodInvocation mi = super.visitMethodInvocation(method, ctx);
@@ -100,11 +102,13 @@ private J.MethodInvocation replace(J.MethodInvocation mi, ExecutionContext ctx)
 
             String actual = typeToIndicator(actualArgument.getType());
             J.MethodInvocation matcherArgumentMethod = (J.MethodInvocation) matcherArgument;
+            boolean isNoArgAssertion = noArgAssertions.contains(assertion);
+            String argsTemplate = isNoArgAssertion ? "" : getArgumentsTemplate(matcherArgumentMethod);
             JavaTemplate template = JavaTemplate.builder(String.format(
                             "assertThat(%s)" +
                             (reasonArgument != null ? ".as(#{any(String)})" : "") +
                             ".%s(%s)",
-                            actual, assertion, getArgumentsTemplate(matcherArgumentMethod)))
+                            actual, assertion, argsTemplate))
                     .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3"))
                     .staticImports(
                             "org.assertj.core.api.Assertions.assertThat",
@@ -122,16 +126,19 @@ actual, assertion, getArgumentsTemplate(matcherArgumentMethod)))
             if (reasonArgument != null) {
                 templateArguments.add(reasonArgument);
             }
-            boolean isCloseTo = CLOSE_TO_MATCHER.matches(matcherArgumentMethod);
-            List<Expression> matcherArgs = matcherArgumentMethod.getArguments();
-            for (int i = 0; i < matcherArgs.size(); i++) {
-                Expression originalArgument = matcherArgs.get(i);
-                if (!(originalArgument instanceof J.Empty)) {
-                    // For closeTo, the tolerance (second argument) type must match the actual value type for within()
-                    if (isCloseTo && i == 1) {
-                        templateArguments.add(ensureMatchingNumericType(originalArgument, actualArgument.getType()));
-                    } else {
-                        templateArguments.add(originalArgument);
+            // Skip adding matcher arguments for assertions that don't take any arguments
+            if (!isNoArgAssertion) {
+                boolean isCloseTo = CLOSE_TO_MATCHER.matches(matcherArgumentMethod);
+                List<Expression> matcherArgs = matcherArgumentMethod.getArguments();
+                for (int i = 0; i < matcherArgs.size(); i++) {
+                    Expression originalArgument = matcherArgs.get(i);
+                    if (!(originalArgument instanceof J.Empty)) {
+                        // For closeTo, the tolerance (second argument) type must match the actual value type for within()
+                        if (isCloseTo && i == 1) {
+                            templateArguments.add(ensureMatchingNumericType(originalArgument, actualArgument.getType()));
+                        } else {
+                            templateArguments.add(originalArgument);
+                        }
                     }
                 }
             }
@@ -140,7 +147,7 @@ actual, assertion, getArgumentsTemplate(matcherArgumentMethod)))
 
         private final MethodMatcher CLOSE_TO_MATCHER = new MethodMatcher("org.hamcrest.Matchers closeTo(..)");
 
-        private Expression ensureMatchingNumericType(Expression toleranceExpr, JavaType actualType) {
+        private Expression ensureMatchingNumericType(Expression toleranceExpr, @Nullable JavaType actualType) {
             JavaType toleranceType = toleranceExpr.getType();
             // Only cast if the actual value is a double/float and tolerance is an integer type
             if ((actualType == JavaType.Primitive.Double || TypeUtils.isOfClassType(actualType, "java.lang.Double")) &&
@@ -175,14 +182,14 @@ private String getArgumentsTemplate(J.MethodInvocation matcherArgument) {
                     .collect(joining(", "));
         }
 
-        private String typeToIndicator(JavaType type) {
+        private String typeToIndicator(@Nullable JavaType type) {
             if (type instanceof JavaType.Array) {
                 type = ((JavaType.Array) type).getElemType();
                 String str = type instanceof JavaType.Primitive || type.toString().startsWith("java.") ?
                         type.toString().replaceAll("<.*>", "") : "java.lang.Object";
                 return String.format("#{anyArray(%s)}", str);
             }
-            if (type instanceof JavaType.Primitive || type.toString().startsWith("java.")) {
+            if (type instanceof JavaType.Primitive || type != null && type.toString().startsWith("java.")) {
                 return "#{any()}";
             }
             return "#{any(java.lang.Object)}";

src/test/java/org/openrewrite/java/testing/hamcrest/HamcrestMatcherToAssertJTest.java

@@ -635,4 +635,45 @@ String reason() {
             );
         }
     }
+
+    @Nested
+    class NoArguments {
+        @Issue("https://github.com/openrewrite/rewrite-testing-frameworks/issues/862")
+        @Test
+        void notNullValueWithClassArgument() {
+            rewriteRun(
+              spec -> spec.recipe(new HamcrestMatcherToAssertJ("notNullValue", "isNotNull", null)),
+              //language=java
+              java(
+                    """
+                  import org.junit.jupiter.api.Test;
+
+                  import static org.hamcrest.MatcherAssert.assertThat;
+                  import static org.hamcrest.Matchers.notNullValue;
+
+                  class ATest {
+                      @Test
+                      void test() {
+                          String str = "Hello world!";
+                          assertThat(str, notNullValue(String.class));
+                      }
+                  }
+                  """,
+                """
+                  import org.junit.jupiter.api.Test;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class ATest {
+                      @Test
+                      void test() {
+                          String str = "Hello world!";
+                          assertThat(str).isNotNull();
+                      }
+                  }
+                  """
+              )
+            );
+        }
+    }
 }