Collapse assertions after conversion (#805)

* Collapse Hamcrest assertions after conversion

* Collapse Hamcrest assertions in single pass

* Also assert JUnit assertions are collapsed after conversion

Author: timtebeek

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

@@ -154,9 +154,10 @@ private String typeToIndicator(JavaType type) {
                         type.toString().replaceAll("<.*>", "") : "java.lang.Object";
                 return String.format("#{anyArray(%s)}", str);
             }
-            String str = type instanceof JavaType.Primitive || type.toString().startsWith("java.") ?
-                    type.toString().replaceAll("<.*>", "") : "java.lang.Object";
-            return String.format("#{any(%s)}", str);
+            if (type instanceof JavaType.Primitive || type.toString().startsWith("java.")) {
+                return "#{any()}";
+            }
+            return "#{any(java.lang.Object)}";
         }
     }
 }

src/test/java/org/openrewrite/java/testing/assertj/AssertJBestPracticesTest.java

@@ -101,6 +101,124 @@ void testMethod(List<String> list) {
         );
     }
 
+    @Nested
+    class CollapseAfterConversion {
+        @Test
+        void hamcrestToCollapsedAssertions() {
+            rewriteRun(
+              spec -> spec.parser(JavaParser.fromJavaVersion().classpathFromResources(new InMemoryExecutionContext(), "hamcrest-3")),
+              //language=java
+              java(
+                """
+                  import java.util.List;
+
+                  import static org.hamcrest.MatcherAssert.assertThat;
+                  import static org.hamcrest.Matchers.*;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertThat(biscuits, is(not(nullValue())));
+                          assertThat(biscuits, hasSize(3));
+                          assertThat(biscuits, hasItem("Chocolate"));
+                      }
+                  }
+                  """,
+                """
+                  import java.util.List;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertThat(biscuits).isNotNull();
+                          assertThat(biscuits)
+                                  .hasSize(3)
+                                  .contains("Chocolate");
+                      }
+                  }
+                  """
+              )
+            );
+        }
+
+        @Test
+        void junitCollapsedAssertions() {
+            rewriteRun(
+              spec -> spec.parser(JavaParser.fromJavaVersion().classpathFromResources(new InMemoryExecutionContext(), "junit-jupiter-api-5")),
+              //language=java
+              java(
+                """
+                  import java.util.List;
+
+                  import static org.junit.jupiter.api.Assertions.*;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertNotNull(biscuits);
+                          assertEquals(3, biscuits.size());
+                          assertTrue(biscuits.contains("Chocolate"));
+                      }
+                  }
+                  """,
+                """
+                  import java.util.List;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertThat(biscuits)
+                                  .hasSize(3)
+                                  .contains("Chocolate");
+                      }
+                  }
+                  """
+              )
+            );
+        }
+
+        @Test
+        void assertjCollapsedAssertions() {
+            rewriteRun(
+              //language=java
+              java(
+                """
+                  import java.util.List;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertThat(biscuits).isNotNull();
+                          assertThat(biscuits).hasSize(3);
+                          assertThat(biscuits).contains("Chocolate");
+                      }
+                  }
+                  """,
+                """
+                  import java.util.List;
+
+                  import static org.assertj.core.api.Assertions.assertThat;
+
+                  class BiscuitTest {
+                      void biscuits() {
+                          List<String> biscuits = List.of("Ginger", "Chocolate", "Oatmeal");
+                          assertThat(biscuits)
+                                  .hasSize(3)
+                                  .contains("Chocolate");
+                      }
+                  }
+                  """
+              )
+            );
+        }
+    }
+
     /**
      * Chained AssertJ assertions should be simplified to the corresponding dedicated assertion, as
      * per <a

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

@@ -22,6 +22,7 @@
 import org.openrewrite.java.JavaParser;
 import org.openrewrite.test.RecipeSpec;
 import org.openrewrite.test.RewriteTest;
+import org.openrewrite.test.TypeValidation;
 
 import static org.openrewrite.java.Assertions.java;
 
@@ -385,7 +386,8 @@ void test() {
         @Test
         void containsInAnyOrderWithArray() {
             rewriteRun(
-              spec -> spec.recipe(new HamcrestMatcherToAssertJ("containsInAnyOrder", "containsExactlyInAnyOrder", null)),
+              spec -> spec.recipe(new HamcrestMatcherToAssertJ("containsInAnyOrder", "containsExactlyInAnyOrder", null))
+                .afterTypeValidationOptions(TypeValidation.all().methodInvocations(false)),
               //language=java
               java(
                     """