Use assertj for assertions (#244)

Author: pivovarit

src/test/java/io/vavr/jackson/datatype/BaseTest.java

@@ -9,14 +9,15 @@
 import io.vavr.Tuple2;
 import io.vavr.collection.List;
 import io.vavr.collection.Seq;
-import org.junit.jupiter.api.Assertions;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.util.Collection;
 import java.util.Map;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class BaseTest {
 
     @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_OBJECT)
@@ -34,10 +35,10 @@ protected void verifySerialization(TypeReference<?> typeReference, List<Tuple2<?
             String expectedJson = testValue._2();
 
             String json = writer.writeValueAsString(src);
-            Assertions.assertEquals(expectedJson, json);
+            assertThat(json).isEqualTo(expectedJson);
 
             Object dst = mapper().readValue(json, typeReference);
-            Assertions.assertEquals(src, dst);
+            assertThat(dst).isEqualTo(src);
         }
     }
 

src/test/java/io/vavr/jackson/datatype/CharSeqTest.java

@@ -4,12 +4,12 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectWriter;
 import io.vavr.collection.CharSeq;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
 
 class CharSeqTest extends BaseTest {
 
@@ -18,9 +18,9 @@ void shouldSerializeAndDeserializeCharSeq() throws IOException {
         ObjectWriter writer = mapper().writer();
         CharSeq src = CharSeq.of("abc");
         String json = writer.writeValueAsString(src);
-        Assertions.assertEquals("\"abc\"", json);
+        assertThat(json).isEqualTo("\"abc\"");
         CharSeq dst = mapper().readValue(json, CharSeq.class);
-        Assertions.assertEquals(src, dst);
+        assertThat((Iterable) dst).isEqualTo(src);
     }
 
     @Test
@@ -29,9 +29,9 @@ void shouldSerializeAndDeserializeWrappedCharSeqAsObject() throws IOException {
         CharSeq src = CharSeq.of("abc");
         String plainJson = mapper().writeValueAsString(src);
         String wrappedJson = mapper.writeValueAsString(src);
-        Assertions.assertEquals(wrappedJson, wrapToObject(CharSeq.class.getName(), plainJson));
+        assertThat(wrapToObject(CharSeq.class.getName(), plainJson)).isEqualTo(wrappedJson);
         CharSeq restored = mapper.readValue(wrappedJson, CharSeq.class);
-        Assertions.assertEquals(src, restored);
+        assertThat((Iterable) restored).isEqualTo(src);
     }
 
     @Test
@@ -40,13 +40,13 @@ void shouldSerializeAndDeserializeWrappedCharSeqAsArray() throws IOException {
         CharSeq src = CharSeq.of("abc");
         String plainJson = mapper().writeValueAsString(src);
         String wrappedJson = mapper.writeValueAsString(src);
-        Assertions.assertEquals(wrappedJson, wrapToArray(CharSeq.class.getName(), plainJson));
+        assertThat(wrapToArray(CharSeq.class.getName(), plainJson)).isEqualTo(wrappedJson);
         CharSeq restored = mapper.readValue(wrappedJson, CharSeq.class);
-        Assertions.assertEquals(src, restored);
+        assertThat((Iterable) restored).isEqualTo(src);
     }
 
     @Test
     void shouldThrowExceptionWhenDeserializingInvalidCharSeq() {
-        assertThrows(JsonMappingException.class, () -> mapper().readValue("42", CharSeq.class));
+        assertThatExceptionOfType(JsonMappingException.class).isThrownBy(() -> mapper().readValue("42", CharSeq.class));
     }
 }

src/test/java/io/vavr/jackson/datatype/EitherTest.java

@@ -12,74 +12,71 @@
 import io.vavr.collection.Set;
 import io.vavr.control.Either;
 import io.vavr.control.Option;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.math.BigInteger;
 
 import static io.vavr.control.Option.none;
 import static io.vavr.control.Option.some;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatExceptionOfType;
 
-public class EitherTest extends BaseTest {
+class EitherTest extends BaseTest {
 
     @Test
     void shouldSerializeAndDeserializeWrappedEitherObject() throws IOException {
         ObjectMapper mapper = mapper().addMixIn(Either.class, WrapperObject.class);
         Either<Integer, Integer> src = Either.right(1);
         String plainJson = mapper().writeValueAsString(src);
         String wrappedJson = mapper.writeValueAsString(src);
-        Assertions.assertEquals(wrappedJson, wrapToObject(Either.Right.class.getName(), plainJson));
+        assertThat(wrapToObject(Either.Right.class.getName(), plainJson)).isEqualTo(wrappedJson);
         Either<Integer, Integer> restored = (Either<Integer, Integer>) mapper.readValue(wrappedJson, Either.class);
-        Assertions.assertEquals(src, restored);
+        assertThat(restored).isEqualTo(src);
     }
 
     @Test
     void shouldSerializeAndDeserializeLeftEither() throws IOException {
         Either<String, Integer> left = Either.left("left");
         String json = mapper().writer().writeValueAsString(left);
         Either<String, Integer> restored = mapper().readValue(json, Either.class);
-        Assertions.assertEquals(left, restored);
+        assertThat(restored).isEqualTo(left);
     }
 
     @Test
     void shouldSerializeAndDeserializeRightEither() throws IOException {
         Either<String, Integer> right = Either.right(1);
         String json = mapper().writer().writeValueAsString(right);
         Either<String, Integer> restored = mapper().readValue(json, Either.class);
-        Assertions.assertEquals(right, restored);
+        assertThat(restored).isEqualTo(right);
     }
 
     @Test
     void shouldThrowExceptionWhenInvalidJsonHasExtraRightValue() throws IOException {
-        Assertions.assertThrows(JsonMappingException.class, () -> {
-            String json = "[\"right\", 2, 3]";
-            mapper().readValue(json, Either.class);
-        });
+        String json = "[\"right\", 2, 3]";
+        assertThatExceptionOfType(JsonMappingException.class).isThrownBy(() ->
+            mapper().readValue(json, Either.class));
     }
 
     @Test
     void shouldThrowExceptionWhenInvalidJsonHasMissingRightValue() throws IOException {
-        Assertions.assertThrows(JsonMappingException.class, () -> {
-            String json = "[\"right\"]";
-            mapper().readValue(json, Either.class);
-        });
+        String json = "[\"right\"]";
+        assertThatExceptionOfType(JsonMappingException.class).isThrownBy(() ->
+            mapper().readValue(json, Either.class));
     }
 
     @Test
     void shouldThrowExceptionWhenInvalidJsonHasMalformedLeftType() throws IOException {
-        Assertions.assertThrows(JsonMappingException.class, () -> {
-            String json = "[\"lEft\", 42]";
-            mapper().readValue(json, Either.class);
-        });
+        String json = "[\"lEft\", 42]";
+        assertThatExceptionOfType(JsonMappingException.class).isThrownBy(() ->
+            mapper().readValue(json, Either.class));
     }
 
     @Test
     void shouldThrowExceptionWhenInvalidJsonHasNonStringLeftOrRight() throws IOException {
-        Assertions.assertThrows(JsonMappingException.class, () -> {
-            String json = "[42, 42]";
-            mapper().readValue(json, Either.class);
-        });
+        String json = "[42, 42]";
+        assertThatExceptionOfType(JsonMappingException.class).isThrownBy(() ->
+            mapper().readValue(json, Either.class));
     }
 
     @Test
@@ -88,7 +85,7 @@ void shouldSerializeAndDeserializeLeftEitherWithGenericTypes() throws IOExceptio
         String json = mapper().writer().writeValueAsString(either);
         Either<List<Integer>, Set<Double>> restored = mapper().readValue(json, new TypeReference<Either<List<Integer>, Set<Double>>>() {
         });
-        Assertions.assertEquals(either, restored);
+        assertThat(restored).isEqualTo(either);
     }
 
     @Test
@@ -97,23 +94,23 @@ void shouldSerializeAndDeserializeRightEitherWithGenericTypes() throws IOExcepti
         String json = mapper().writer().writeValueAsString(either);
         Either<List<Integer>, Set<Double>> restored = mapper().readValue(json, new TypeReference<Either<List<Integer>, Set<Double>>>() {
         });
-        Assertions.assertEquals(either, restored);
+        assertThat(restored).isEqualTo(either);
     }
 
     @Test
     void shouldHandleNullInLeftEitherDuringSerialization() throws IOException {
         Either<String, Integer> left = Either.left(null);
         String leftJson = mapper().writer().writeValueAsString(left);
         Either<String, Integer> restoredLeft = mapper().readValue(leftJson, Either.class);
-        Assertions.assertEquals(left, restoredLeft);
+        assertThat(restoredLeft).isEqualTo(left);
     }
 
     @Test
     void shouldHandleNullInRightEitherDuringSerialization() throws IOException {
         Either<String, Integer> right = Either.left(null);
         String rightJson = mapper().writer().writeValueAsString(right);
         Either<String, Integer> restoredRight = mapper().readValue(rightJson, Either.class);
-        Assertions.assertEquals(right, restoredRight);
+        assertThat(restoredRight).isEqualTo(right);
     }
 
     @Test
@@ -132,13 +129,13 @@ void shouldSerializeAndDeserializeEitherWithOption() throws IOException {
     void shouldSerializeAndDeserializeCustomTypeWithJsonTypeInfo() throws IOException {
         String javaUtilValue;
         javaUtilValue = mapper().writeValueAsString(new Left());
-        Assertions.assertEquals("{\"f\":[\"left\",{\"card\":{\"type\":\"hello\"}}]}", javaUtilValue);
+        assertThat(javaUtilValue).isEqualTo("{\"f\":[\"left\",{\"card\":{\"type\":\"hello\"}}]}");
         Left restoredLeft = mapper().readValue(javaUtilValue, Left.class);
-        Assertions.assertEquals("hello", restoredLeft.f.getLeft().type);
+        assertThat(restoredLeft.f.getLeft().type).isEqualTo("hello");
         javaUtilValue = mapper().writeValueAsString(new Right());
-        Assertions.assertEquals("{\"f\":[\"right\",{\"card\":{\"type\":\"hello\"}}]}", javaUtilValue);
+        assertThat(javaUtilValue).isEqualTo("{\"f\":[\"right\",{\"card\":{\"type\":\"hello\"}}]}");
         Right restoredRight = mapper().readValue(javaUtilValue, Right.class);
-        Assertions.assertEquals("hello", restoredRight.f.get().type);
+        assertThat(restoredRight.f.get().type).isEqualTo("hello");
     }
 
     @Test
@@ -151,13 +148,13 @@ void shouldSerializeAndDeserializeScalaEither() throws IOException {
         final Either<String, BigInteger> deserializedLeft =
             mapper.readValue(serializedLeft, new TypeReference<Either<String, BigInteger>>() {
             });
-        Assertions.assertEquals("test", deserializedLeft.getLeft());
+        assertThat(deserializedLeft.getLeft()).isEqualTo("test");
 
         final String serializedRight = mapper.writeValueAsString(right);
         final Either<String, BigInteger> deserializedRight =
             mapper.readValue(serializedRight, new TypeReference<Either<String, BigInteger>>() {
             });
-        Assertions.assertEquals(BigInteger.ONE, deserializedRight.get());
+        assertThat(deserializedRight.get()).isEqualTo(BigInteger.ONE);
     }
 
     @JsonTypeInfo(