More Hamcrest Migrations for Number Matchers (#379)

* removed containsInRelativeOrder from yaml list

* initial commit

* first test passes

* changed name

* updating file name

* updates

* updated tests and added support for the BigDecimal type with closeTo()

* removed dedicated recipe, realized it could be generalized

* fixed bug and added another test

Author: AlekSimpson

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

@@ -70,6 +70,7 @@ 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)");
 
+
         @Override
         public J.MethodInvocation visitMethodInvocation(J.MethodInvocation method, ExecutionContext ctx) {
             J.MethodInvocation mi = super.visitMethodInvocation(method, ctx);
@@ -97,12 +98,15 @@ private J.MethodInvocation handleTwoArgumentCase(J.MethodInvocation mi, Executio
             String argumentsTemplate = originalArguments.stream()
                     .map(a -> typeToIndicator(a.getType()))
                     .collect(Collectors.joining(", "));
+            argumentsTemplate = applySpecialCases((J.MethodInvocation) matcherArgument, argumentsTemplate);
+
             JavaTemplate template = JavaTemplate.builder(String.format("assertThat(%s).%s(%s)",
                             actual, assertion, argumentsTemplate))
                     .javaParser(JavaParser.fromJavaVersion().classpathFromResources(ctx, "assertj-core-3.24"))
-                    .staticImports("org.assertj.core.api.Assertions.assertThat")
+                    .staticImports("org.assertj.core.api.Assertions.assertThat", "org.assertj.core.api.Assertions.within")
                     .build();
             maybeAddImport("org.assertj.core.api.Assertions", "assertThat");
+            maybeAddImport("org.assertj.core.api.Assertions", "within");
             maybeRemoveImport("org.hamcrest.Matchers." + matcher);
             maybeRemoveImport("org.hamcrest.MatcherAssert.assertThat");
 
@@ -154,5 +158,24 @@ private String typeToIndicator(JavaType type) {
                 return String.format("#{any(%s)}", str);
             }
         }
+
+        private String applySpecialCases(J.MethodInvocation mi, String template) {
+            final MethodMatcher CLOSE_TO_MATCHER = new MethodMatcher("org.hamcrest.Matchers closeTo(..)");
+            String[] splitTemplate = template.split(", ");
+
+            if (CLOSE_TO_MATCHER.matches(mi)) {
+                List<String> newTemplateArr = new ArrayList<>();
+                for (int i = 0; i<splitTemplate.length; i++) {
+                    // within needs to placed on the second argument of isCloseTo
+                    if (i == 1) {
+                        newTemplateArr.add(String.format("within(%s)", splitTemplate[i]));
+                        continue;
+                    }
+                    newTemplateArr.add(splitTemplate[i]);
+                }
+                return String.join(", ", newTemplateArr);
+            }
+            return template;
+        }
     }
 }

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

@@ -366,6 +366,82 @@ void test() {
                   """)
             );
         }
+
+        @Test
+        void closeToTest() {
+            rewriteRun(
+              spec -> spec.recipe(new HamcrestMatcherToAssertJ("closeTo", "isCloseTo")),
+              //language=java
+              java("""
+                  import org.junit.jupiter.api.Test;
+                  
+                  import static org.hamcrest.MatcherAssert.assertThat;
+                  import static org.hamcrest.Matchers.closeTo;
+                  
+                  class ATest {
+                      @Test
+                      void replaceCloseTo() {
+                          assertThat(1.0, closeTo(2.0, 1.0));
+                      }
+                  }
+                  """,
+                """
+                  import org.junit.jupiter.api.Test;
+                  
+                  import static org.assertj.core.api.Assertions.assertThat;
+                  import static org.assertj.core.api.Assertions.within;
+                  
+                  class ATest {
+                      @Test
+                      void replaceCloseTo() {
+                          assertThat(1.0).isCloseTo(2.0, within(1.0));
+                      }
+                  }
+                  """)
+            );
+        }
+
+        @Test
+        void closeToWorksWithBigDecimal() {
+            rewriteRun(
+              spec -> spec.recipe(new HamcrestMatcherToAssertJ("closeTo", "isCloseTo")),
+              //language=java
+              java("""
+                  import org.junit.jupiter.api.Test;
+                  import java.math.BigDecimal;
+                  
+                  import static org.hamcrest.MatcherAssert.assertThat;
+                  import static org.hamcrest.Matchers.closeTo;
+                  
+                  class ATest {
+                      @Test
+                      void replaceCloseTo() {
+                          BigDecimal x = new BigDecimal("1.000005");
+                          BigDecimal y = new BigDecimal("2.0");
+                          BigDecimal z = new BigDecimal("0.0005");
+                          assertThat(x, closeTo(y, z));
+                      }
+                  }
+                  """,
+                """
+                  import org.junit.jupiter.api.Test;
+                  import java.math.BigDecimal;
+                  
+                  import static org.assertj.core.api.Assertions.assertThat;
+                  import static org.assertj.core.api.Assertions.within;
+                  
+                  class ATest {
+                      @Test
+                      void replaceCloseTo() {
+                          BigDecimal x = new BigDecimal("1.000005");
+                          BigDecimal y = new BigDecimal("2.0");
+                          BigDecimal z = new BigDecimal("0.0005");
+                          assertThat(x).isCloseTo(y, within(z));
+                      }
+                  }
+                  """)
+            );
+        }
     }
 
     @Nested