use OpenRewrite to migrate from Hamcrest to AssertJ

pom.xml

@@ -87,18 +87,6 @@
             <version>1.7.32</version>
             <scope>test</scope>
         </dependency>
-        <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest</artifactId>
-            <version>2.2</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.hamcrest</groupId>
-            <artifactId>hamcrest-library</artifactId>
-            <version>1.3</version>
-            <scope>test</scope>
-        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
@@ -123,6 +111,12 @@
             <version>1.10.1</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.27.3</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <plugins>
@@ -152,14 +146,14 @@
                 <configuration>
                     <exportDatatables>true</exportDatatables>
                     <activeRecipes>
-                        <recipe>org.openrewrite.java.testing.junit5.JUnit4to5Migration</recipe>
+                        <recipe>org.openrewrite.java.testing.hamcrest.MigrateHamcrestToAssertJ</recipe>
                     </activeRecipes>
                 </configuration>
                 <dependencies>
                     <dependency>
                         <groupId>org.openrewrite.recipe</groupId>
                         <artifactId>rewrite-testing-frameworks</artifactId>
-                        <version>3.5.1</version>
+                        <version>3.24.0</version>
                     </dependency>
                 </dependencies>
             </plugin>

src/test/java/org/thejavaguy/javafaker/AddressTest.java

@@ -1,15 +1,6 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.emptyOrNullString;
-import static org.hamcrest.Matchers.emptyString;
-import static org.hamcrest.Matchers.greaterThanOrEqualTo;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.lessThanOrEqualTo;
-import static org.hamcrest.Matchers.not;
-import static org.thejavaguy.javafaker.matchers.IsANumber.isANumber;
-import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import java.text.DecimalFormatSymbols;
 import java.util.Locale;
@@ -24,13 +15,13 @@ public class AddressTest extends AbstractFakerTest {
     @Test
     public void testStreetAddressStartsWithNumber() {
         final String streetAddressNumber = faker.address().streetAddress();
-        assertThat(streetAddressNumber, matchesRegularExpression("[0-9]+ .+"));
+        assertThat(streetAddressNumber).matches("[0-9]+ .+");
     }
 
     @Test
     public void testStreetAddressIsANumber() {
         final String streetAddressNumber = faker.address().streetAddressNumber();
-        assertThat(streetAddressNumber, matchesRegularExpression("[0-9]+"));
+        assertThat(streetAddressNumber).matches("[0-9]+");
     }
 
     @Test
@@ -39,10 +30,10 @@ public void testLatitude() {
         Double lat;
         for (int i = 0; i < 100; i++) {
             latStr = faker.address().latitude().replace(decimalSeparator, '.');
-            assertThat(latStr, isANumber());
+            assertThat(latStr).matches("-?\\d+(\\.\\d+)?");
             lat = Double.valueOf(latStr);
-            assertThat("Latitude is less then -90", lat, greaterThanOrEqualTo(-90.0));
-            assertThat("Latitude is greater than 90", lat, lessThanOrEqualTo(90.0));
+            assertThat(lat).as("Latitude is less then -90").isGreaterThanOrEqualTo(-90.0);
+            assertThat(lat).as("Latitude is greater than 90").isLessThanOrEqualTo(90.0);
         }
     }
 
@@ -52,81 +43,81 @@ public void testLongitude() {
         Double lon;
         for (int i = 0; i < 100; i++) {
             longStr = faker.address().longitude().replace(decimalSeparator, '.');
-            assertThat(longStr, isANumber());
+            assertThat(longStr).matches("-?\\d+(\\.\\d+)?");
             lon = Double.valueOf(longStr);
-            assertThat("Longitude is less then -180", lon, greaterThanOrEqualTo(-180.0));
-            assertThat("Longitude is greater than 180", lon, lessThanOrEqualTo(180.0));
+            assertThat(lon).as("Longitude is less then -180").isGreaterThanOrEqualTo(-180.0);
+            assertThat(lon).as("Longitude is greater than 180").isLessThanOrEqualTo(180.0);
         }
     }
 
     @Test
     public void testTimeZone() {
-        assertThat(faker.address().timeZone(), matchesRegularExpression("[A-Za-z_]+/[A-Za-z_]+[/A-Za-z_]*"));
+        assertThat(faker.address().timeZone()).matches("[A-Za-z_]+/[A-Za-z_]+[/A-Za-z_]*");
     }
 
     @Test
     public void testState() {
-        assertThat(faker.address().state(), matchesRegularExpression("[A-Za-z ]+"));
+        assertThat(faker.address().state()).matches("[A-Za-z ]+");
     }
 
     @Test
     public void testCity() {
-        assertThat(faker.address().city(), matchesRegularExpression("[A-Za-z'() ]+"));
+        assertThat(faker.address().city()).matches("[A-Za-z'() ]+");
     }
 
     @Test
     public void testCityName() {
-        assertThat(faker.address().cityName(), matchesRegularExpression("[A-Za-z'() ]+"));
+        assertThat(faker.address().cityName()).matches("[A-Za-z'() ]+");
     }
 
     @Test
     public void testCountry() {
-        assertThat(faker.address().country(), matchesRegularExpression("[A-Za-z\\- &.,'()\\d]+"));
+        assertThat(faker.address().country()).matches("[A-Za-z\\- &.,'()\\d]+");
     }
 
     @Test
     public void testCountryCode() {
-        assertThat(faker.address().countryCode(), matchesRegularExpression("[A-Za-z ]+"));
+        assertThat(faker.address().countryCode()).matches("[A-Za-z ]+");
     }
 
     @Test
     public void testStreetAddressIncludeSecondary() {
-        assertThat(faker.address().streetAddress(true), is(not(emptyString())));
+        assertThat(faker.address().streetAddress(true)).isNotEmpty();
     }
 
     @Test
     public void testCityWithLocaleFranceAndSeed() {
         long seed = 1L;
         Faker firstFaker = new Faker(Locale.FRANCE, new Random(seed));
         Faker secondFaker = new Faker(Locale.FRANCE, new Random(seed));
-        assertThat(firstFaker.address().city(), is(secondFaker.address().city()));
+        assertThat(firstFaker.address().city()).isEqualTo(secondFaker.address().city());
     }
 
     @Test
     public void testFullAddress() {
-        assertThat(faker.address().fullAddress(), is(not(emptyOrNullString())));
+        assertThat(faker.address().fullAddress()).isNotEmpty();
     }
 
     @Test
     public void testZipCodeByState() {
         faker = new Faker(new Locale("en-US"));
-        assertThat(faker.address().zipCodeByState(faker.address().stateAbbr()), matchesRegularExpression("[0-9]{5}"));
+        assertThat(faker.address().zipCodeByState(faker.address().stateAbbr())).matches("[0-9]{5}");
     }
 
     @Test
     public void testHungarianZipCodeByState() {
         faker = new Faker(new Locale("hu"));
-        assertThat(faker.address().zipCodeByState(faker.address().stateAbbr()), matchesRegularExpression("[0-9]{4}"));
+        assertThat(faker.address().zipCodeByState(faker.address().stateAbbr())).matches("[0-9]{4}");
     }
 
     @Test
     public void testCountyByZipCode() {
         faker = new Faker(new Locale("en-US"));
-        assertThat(faker.address().countyByZipCode("47732"), is(not(emptyOrNullString())));
+        assertThat(faker.address().countyByZipCode("47732")).isNotEmpty();
     }
 
     @Test
     public void testStreetPrefix() {
-        assertThat(faker.address().streetPrefix(), isStringWithContents());
+        assertThat(faker.address().streetPrefix()).isNotBlank();
     }
 }

src/test/java/org/thejavaguy/javafaker/AncientTest.java

@@ -1,30 +1,29 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class AncientTest extends AbstractFakerTest {
 
     @Test
     public void god() {
-        assertThat(faker.ancient().god(), matchesRegularExpression("\\w+"));
+        assertThat(faker.ancient().god()).matches("\\w+");
     }
 
     @Test
     public void primordial() {
-        assertThat(faker.ancient().primordial(), matchesRegularExpression("\\w+"));
+        assertThat(faker.ancient().primordial()).matches("\\w+");
     }
 
     @Test
     public void titan() {
-        assertThat(faker.ancient().titan(), matchesRegularExpression("\\w+"));
+        assertThat(faker.ancient().titan()).matches("\\w+");
     }
 
     @Test
     public void hero() {
-        assertThat(faker.ancient().hero(), matchesRegularExpression("(?U)\\w+"));
+        assertThat(faker.ancient().hero()).matches("(?U)\\w+");
     }
 
 }

src/test/java/org/thejavaguy/javafaker/AnimalTest.java

@@ -1,15 +1,14 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class AnimalTest extends AbstractFakerTest {
 
     @Test
     public void name() {
-        assertThat(faker.animal().name(), matchesRegularExpression("[A-Za-z ]+"));
+        assertThat(faker.animal().name()).matches("[A-Za-z ]+");
     }
 
 }

src/test/java/org/thejavaguy/javafaker/AppTest.java

@@ -1,24 +1,23 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class AppTest extends AbstractFakerTest {
 
     @Test
     public void testName() {
-        assertThat(faker.app().name(), matchesRegularExpression("([\\w-]+ ?)+"));
+        assertThat(faker.app().name()).matches("([\\w-]+ ?)+");
     }
 
     @Test
     public void testVersion() {
-        assertThat(faker.app().version(), matchesRegularExpression("\\d\\.(\\d){1,2}(\\.\\d)?"));
+        assertThat(faker.app().version()).matches("\\d\\.(\\d){1,2}(\\.\\d)?");
     }
 
     @Test
     public void testAuthor() {
-        assertThat(faker.app().author(), matchesRegularExpression("([\\w']+[-&,\\.]? ?){2,9}"));
+        assertThat(faker.app().author()).matches("([\\w']+[-&,\\.]? ?){2,9}");
     }
 }

src/test/java/org/thejavaguy/javafaker/AquaTeenHungerForceTest.java

@@ -1,15 +1,14 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class AquaTeenHungerForceTest extends AbstractFakerTest {
 
     @Test
     public void character() {
-        assertThat(faker.aquaTeenHungerForce().character(), matchesRegularExpression("[A-Za-z .]+"));
+        assertThat(faker.aquaTeenHungerForce().character()).matches("[A-Za-z .]+");
     }
 
 }

src/test/java/org/thejavaguy/javafaker/ArtistTest.java

@@ -1,14 +1,13 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class ArtistTest extends AbstractFakerTest {
 
     @Test
     public void name() {
-        assertThat(faker.artist().name(), matchesRegularExpression("(\\w+ ?){1,2}"));
+        assertThat(faker.artist().name()).matches("(\\w+ ?){1,2}");
     }
 }

src/test/java/org/thejavaguy/javafaker/AvatarTest.java

@@ -1,7 +1,6 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.TestTemplate;
 import org.thejavaguy.javafaker.repeating.Repeat;
@@ -12,6 +11,6 @@ public class AvatarTest extends AbstractFakerTest {
     @Repeat(times=10)
     public void testAvatar() {
         String avatar = faker.avatar().image();
-        assertThat(avatar, matchesRegularExpression("^https:\\/\\/s3.amazonaws\\.com\\/uifaces\\/faces\\/twitter\\/[a-zA-Z0-9_]+\\/128\\.jpg$"));
+        assertThat(avatar).matches("^https:\\/\\/s3.amazonaws\\.com\\/uifaces\\/faces\\/twitter\\/[a-zA-Z0-9_]+\\/128\\.jpg$");
     }
 }

src/test/java/org/thejavaguy/javafaker/AviationTest.java

@@ -1,25 +1,23 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class AviationTest extends AbstractFakerTest {
 
     @Test
     public void airport() {
-        assertThat(faker.aviation().airport(), matchesRegularExpression("\\w{4}"));
+        assertThat(faker.aviation().airport()).matches("\\w{4}");
     }
 
     @Test
     public void aircraft() {
-        assertThat(faker.aviation().aircraft(), isStringWithContents());
+        assertThat(faker.aviation().aircraft()).isNotBlank();
     }
 
     @Test
     public void metar() {
-        assertThat(faker.aviation().METAR(), isStringWithContents());
+        assertThat(faker.aviation().METAR()).isNotBlank();
     }
 }

src/test/java/org/thejavaguy/javafaker/BackToTheFutureTest.java

@@ -1,25 +1,23 @@
 package org.thejavaguy.javafaker;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.thejavaguy.javafaker.matchers.IsStringWithContents.isStringWithContents;
-import static org.thejavaguy.javafaker.matchers.MatchesRegularExpression.matchesRegularExpression;
+import static org.assertj.core.api.Assertions.assertThat;
 
 import org.junit.jupiter.api.Test;
 
 public class BackToTheFutureTest extends AbstractFakerTest {
 
     @Test
     public void character() {
-        assertThat(faker.backToTheFuture().character(), isStringWithContents());
+        assertThat(faker.backToTheFuture().character()).isNotBlank();
     }
 
     @Test
     public void date() {
-        assertThat(faker.backToTheFuture().date(), matchesRegularExpression("([A-za-z]{3,8}) ([1-9]|[1-2]\\d|3[0-1]), (18[8-9]\\d|19[0-9]\\d|200\\d|201[0-5])"));
+        assertThat(faker.backToTheFuture().date()).matches("([A-za-z]{3,8}) ([1-9]|[1-2]\\d|3[0-1]), (18[8-9]\\d|19[0-9]\\d|200\\d|201[0-5])");
     }
 
     @Test
     public void quote() {
-        assertThat(faker.backToTheFuture().quote(), isStringWithContents());
+        assertThat(faker.backToTheFuture().quote()).isNotBlank();
     }
 }