Merge pull request #81 from jdsatlin/allow-nullable-either-contents

feat(80): Allow for asserting on Eithers containing null values within them

Author: rcardin

src/main/kotlin/in/rcard/assertj/arrowcore/AbstractEitherAssert.kt

@@ -25,8 +25,8 @@ import org.assertj.core.internal.StandardComparisonStrategy
  */
 abstract class AbstractEitherAssert<
     SELF : AbstractEitherAssert<SELF, LEFT, RIGHT>,
-    LEFT : Any,
-    RIGHT : Any,
+    LEFT : Any?,
+    RIGHT : Any?,
 > internal constructor(
     either: Either<LEFT, RIGHT>?,
 ) : AbstractObjectAssert<SELF, Either<LEFT, RIGHT>>(either, AbstractEitherAssert::class.java) {

src/main/kotlin/in/rcard/assertj/arrowcore/EitherAssert.kt

@@ -10,10 +10,10 @@ import arrow.core.Either
  * @author Riccardo Cardin
  * @since 0.0.1
  */
-class EitherAssert<LEFT : Any, RIGHT : Any> private constructor(either: Either<LEFT, RIGHT>?) :
+class EitherAssert<LEFT : Any?, RIGHT : Any?> private constructor(either: Either<LEFT, RIGHT>?) :
     AbstractEitherAssert<EitherAssert<LEFT, RIGHT>, LEFT, RIGHT>(either) {
     companion object {
-        fun <LEFT : Any, RIGHT : Any> assertThat(actual: Either<LEFT, RIGHT>?): EitherAssert<LEFT, RIGHT> =
+        fun <LEFT : Any?, RIGHT : Any?> assertThat(actual: Either<LEFT, RIGHT>?): EitherAssert<LEFT, RIGHT> =
             EitherAssert(actual)
     }
 }

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldContain.kt

@@ -9,7 +9,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * @author Riccardo Cardin
  * @since 0.0.1
  */
-internal class EitherShouldContain private constructor(message: String, actual: Either<Any, Any>, expected: Any) :
+internal class EitherShouldContain private constructor(message: String, actual: Either<Any?, Any?>, expected: Any?) :
     BasicErrorMessageFactory(message, actual, expected) {
 
     companion object {
@@ -28,7 +28,7 @@ internal class EitherShouldContain private constructor(message: String, actual:
          * @param RIGHT         the type of the value contained in the [Either] on the right side.
          * @return an error message factory
          */
-        internal fun <LEFT : Any, RIGHT : Any> shouldContainOnRight(
+        internal fun <LEFT : Any?, RIGHT : Any?> shouldContainOnRight(
             actual: Either<LEFT, RIGHT>,
             expectedValue: RIGHT,
         ): EitherShouldContain = EitherShouldContain(
@@ -46,7 +46,7 @@ internal class EitherShouldContain private constructor(message: String, actual:
          * @param RIGHT       the type of the value contained in the [Either] on the right side.
          * @return an error message factory
          */
-        internal fun <LEFT : Any, RIGHT : Any> shouldContainOnLeft(
+        internal fun <LEFT : Any?, RIGHT : Any?> shouldContainOnLeft(
             actual: Either<LEFT, RIGHT>,
             expectedValue: RIGHT,
         ): EitherShouldContain = EitherShouldContain(

src/main/kotlin/in/rcard/assertj/arrowcore/errors/EitherShouldContainInstanceOf.kt

@@ -30,7 +30,7 @@ internal class EitherShouldContainInstanceOf private constructor(message: String
          * @throws java.lang.NullPointerException if either is null.
          */
         internal fun shouldContainOnRightInstanceOf(
-            actual: Either<Any, Any>,
+            actual: Either<Any?, Any?>,
             expectedClass: Class<*>,
         ): EitherShouldContainInstanceOf =
             actual.fold(
@@ -47,14 +47,14 @@ internal class EitherShouldContainInstanceOf private constructor(message: String
                         EXPECTING_TO_CONTAIN_DIFFERENT_INSTANCE.format(
                             actual.javaClass.simpleName,
                             expectedClass.name,
-                            rightValue.javaClass.name,
+                            rightValue?.javaClass?.name ?: "null",
                         ),
                     )
                 },
             )
 
         internal fun shouldContainOnLeftInstanceOf(
-            actual: Either<Any, Any>,
+            actual: Either<Any?, Any?>,
             expectedClass: Class<*>,
         ): EitherShouldContainInstanceOf =
             actual.fold(
@@ -63,7 +63,7 @@ internal class EitherShouldContainInstanceOf private constructor(message: String
                         EXPECTING_TO_CONTAIN_DIFFERENT_INSTANCE.format(
                             actual.javaClass.simpleName,
                             expectedClass.name,
-                            leftValue.javaClass.name,
+                            leftValue?.javaClass?.name ?: "null",
                         ),
                     )
                 },

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_asLeft_Test.kt

@@ -17,6 +17,12 @@ internal class EitherAssert_asLeft_Test {
         assertThat(actualLeftValue).asLeft().isEqualTo(42)
     }
 
+    @Test
+    internal fun `should return a valid Object assert if the either contains a left-sided null`() {
+        val actualLeftValue: Either<Int?, Nothing> = null.left()
+        assertThat(actualLeftValue).asLeft().isEqualTo(null)
+    }
+
     @Test
     internal fun `should fail if the either contains a right-sided value`() {
         val actualRightValue: Either<Nothing, String> = "42".right()
@@ -26,7 +32,15 @@ internal class EitherAssert_asLeft_Test {
     }
 
     @Test
-    internal fun `should fail if the either is null`() {
+    internal fun `should fail if the either contains a right-sided null`() {
+        val actualRightValue: Either<Nothing, String?> = null.right()
+        Assertions.assertThatThrownBy { assertThat(actualRightValue).asLeft() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeLeft(actualRightValue).create())
+    }
+
+    @Test
+    internal fun `should fail if the either itself is null`() {
         val actualLeftValue: Either<Int, Nothing>? = null
         Assertions.assertThatThrownBy { assertThat(actualLeftValue).asLeft() }
             .isInstanceOf(AssertionError::class.java)

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_asRight_Test.kt

@@ -17,6 +17,12 @@ internal class EitherAssert_asRight_Test {
         assertThat(actualRightValue).asRight().isEqualTo(42)
     }
 
+    @Test
+    internal fun `should return a valid Object assert if either contains a right-sided null`() {
+        val actualRightValue: Either<Nothing, Int?> = null.right()
+        assertThat(actualRightValue).asRight().isEqualTo(null)
+    }
+
     @Test
     internal fun `should fail if the either contains a left-sided value`() {
         val actualLeftValue: Either<String, Nothing> = "42".left()
@@ -26,7 +32,15 @@ internal class EitherAssert_asRight_Test {
     }
 
     @Test
-    internal fun `should fail if the either is null`() {
+    internal fun `should fail if either contains a left-sided null`() {
+        val actualLeftValue: Either<String?, Nothing> = null.left()
+        Assertions.assertThatThrownBy { assertThat(actualLeftValue).asRight() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actualLeftValue).create())
+    }
+
+    @Test
+    internal fun `should fail if the either itself is null`() {
         val actualRightValue: Either<Nothing, Int>? = null
         Assertions.assertThatThrownBy { assertThat(actualRightValue).asRight() }
             .isInstanceOf(AssertionError::class.java)

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeftInstanceOf_Test.kt

@@ -35,13 +35,41 @@ internal class EitherAssert_containsOnLeftInstanceOf_Test {
             .hasMessage(shouldBeLeft(actual).create())
     }
 
+    @Test
+    internal fun `should fail if either contains a right-sided null`() {
+        val actual: Either<Any, String?> = null.right()
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsLeftInstanceOf(
+                Any::class.java,
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeLeft(actual).create())
+    }
+
     @Test
     internal fun `should pass if either contains required type on left`() {
         val actual: Either<String, Nothing> = "something".left()
         assertThat(actual)
             .containsLeftInstanceOf(String::class.java)
     }
 
+    @Test
+    internal fun `should fail if either contains null value for type on left`() {
+        val actual: Either<String?, Nothing> = null.left()
+        Assertions.assertThatThrownBy {
+            assertThat(actual)
+                .containsLeftInstanceOf(String::class.java)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(
+                shouldContainOnLeftInstanceOf(
+                    actual,
+                    String::class.java
+                ).create()
+            )
+    }
+
     @Test
     internal fun `should pass if either contains required type subclass on left`() {
         val actual = Child().left()

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnLeft_Test.kt

@@ -28,6 +28,12 @@ internal class EitherAssert_containsOnLeft_Test {
         EitherAssert.assertThat(leftValue).containsOnLeft("something")
     }
 
+    @Test
+    internal fun `should pass if either contains an expected null on left side`() {
+        val leftValue = null.left()
+        EitherAssert.assertThat(leftValue).containsOnLeft(null)
+    }
+
     @Test
     internal fun `should fail if either does not contain expected value on left side`() {
         val actual: Either<String, Nothing> = "something".left()
@@ -41,6 +47,19 @@ internal class EitherAssert_containsOnLeft_Test {
             .hasMessage(shouldContainOnLeft(actual, expectedValue).create())
     }
 
+    @Test
+    internal fun `should fail with informative error message if null is contained on left side and a value was expected`() {
+        val actual: Either<String?, Nothing> = null.left()
+        val expectedValue = "something"
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnLeft(
+                expectedValue,
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldContainOnLeft(actual, expectedValue).create())
+    }
+
     @Test
     internal fun `should fail if either is right`() {
         val actual: Either<String, String> = "nothing".right()
@@ -53,4 +72,17 @@ internal class EitherAssert_containsOnLeft_Test {
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldBeLeft(actual).create())
     }
+
+    @Test
+    internal fun `should fail if either right-sided value is null`() {
+        val actual: Either<String, String?> = null.right()
+        val expectedValue = "something"
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnLeft(
+                expectedValue,
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeLeft(actual).create())
+    }
 }

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRightInstanceOf_Test.kt

@@ -48,6 +48,34 @@ internal class EitherAssert_containsOnRightInstanceOf_Test {
             )
     }
 
+    @Test
+    internal fun `should fail if either contains a left-sided null`() {
+        val actual: Either<String?, Any> = null.left()
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsRightInstanceOf(
+                Any::class.java,
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actual).create())
+    }
+
+    @Test
+    internal fun `should fail if either contains null value for type on right`() {
+        val actual: Either<Nothing, String?> = null.right()
+        Assertions.assertThatThrownBy {
+            assertThat(actual)
+                .containsRightInstanceOf(String::class.java)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(
+                shouldContainOnRightInstanceOf(
+                    actual,
+                    String::class.java
+                ).create()
+            )
+    }
+
     @Test
     internal fun `should pass if either contains required type subclass on right`() {
         val actual = Child().right()

src/test/kotlin/in/rcard/assertj/arrowcore/EitherAssert_containsOnRight_Test.kt

@@ -11,7 +11,7 @@ import org.junit.jupiter.api.Test
 
 internal class EitherAssert_containsOnRight_Test {
     @Test
-    internal fun `should fail when either is null`() {
+    internal fun `should fail when either itself is null`() {
         val rightValue: Either<Nothing, String>? = null
         Assertions.assertThatThrownBy {
             EitherAssert.assertThat(rightValue).containsOnRight(
@@ -28,6 +28,12 @@ internal class EitherAssert_containsOnRight_Test {
         EitherAssert.assertThat(rightValue).containsOnRight("something")
     }
 
+    @Test
+    internal fun `should pass if either contains a null on right side`() {
+        val rightValue = null.right()
+        EitherAssert.assertThat(rightValue).containsOnRight(null)
+    }
+
     @Test
     internal fun should_fail_if_either_is_left() {
         val actual: Either<String, String> = "nothing".left()
@@ -39,6 +45,17 @@ internal class EitherAssert_containsOnRight_Test {
             .hasMessage(shouldBeRight(actual).create())
     }
 
+    @Test
+    internal fun `should fail if either contains a left sided null`() {
+        val actual: Either<String?, String> = null.left()
+        val expectedValue = "something"
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnRight(expectedValue)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actual).create())
+    }
+
     @Test
     internal fun `should fail if either does not contain expected value on right side`() {
         val actual: Either<Nothing, String> = "something".right()
@@ -49,4 +66,15 @@ internal class EitherAssert_containsOnRight_Test {
             .isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldContainOnRight(actual, expectedValue).create())
     }
+
+    @Test
+    internal fun `should fail with informative error message if either contains null on right but a value was expected`() {
+        val actual: Either<Nothing, String?> = null.right()
+        val expectedValue = "nothing"
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(actual).containsOnRight(expectedValue)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldContainOnRight(actual, expectedValue).create())
+    }
 }