Added isLeft assertion and refactored using the BasicErrorMessageFactory approach for errors, instead of the raw strings

Author: rcardin-lm

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

@@ -1,6 +1,8 @@
 package `in`.rcard.assertj.arrowcore
 
 import arrow.core.Either
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeLeft.Companion.shouldBeLeft
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeRight.Companion.shouldBeRight
 import org.assertj.core.api.AbstractObjectAssert
 
 /**
@@ -19,10 +21,24 @@ abstract class AbstractEitherAssert<SELF : AbstractEitherAssert<SELF, LEFT, RIGH
      *
      * @return this assertion object.
      */
-    fun isRight() {
+    fun isRight(): SELF {
         isNotNull
         if (!actual.isRight()) {
-            failWithMessage("%nExpected Either to be right but was <%s>", actual)
+            throwAssertionError(shouldBeRight(actual))
         }
+        return myself
+    }
+
+    /**
+     * Verifies that the actual [Either] is left.
+     *
+     * @return this assertion object.
+     */
+    fun isLeft(): SELF {
+        isNotNull
+        if (!actual.isLeft()) {
+            throwAssertionError(shouldBeLeft(actual))
+        }
+        return myself
     }
 }

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

@@ -0,0 +1,18 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Either
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build error message when an [Either] should be left.
+ *
+ * @author Riccardo Cardin
+ */
+class EitherShouldBeLeft(actual: Either<*, *>) :
+    BasicErrorMessageFactory("%nExpecting an Either to be left but was <$actual>.") {
+    companion object {
+        fun shouldBeLeft(actual: Either<*, *>): EitherShouldBeLeft {
+            return EitherShouldBeLeft(actual)
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Either
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build error message when an [Either] should be right.
+ *
+ * @author Riccardo Cardin
+ */
+class EitherShouldBeRight(actual: Either<*, *>) :
+    BasicErrorMessageFactory("%nExpecting an Either to be right but was <$actual>.") {
+    companion object {
+        fun shouldBeRight(actual: Either<*, *>): EitherShouldBeRight {
+            return EitherShouldBeRight(actual)
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeLeft.Companion.shouldBeLeft
+import org.assertj.core.api.Assertions
+import org.assertj.core.util.FailureMessages
+import org.junit.jupiter.api.Test
+
+class EitherAssert_isLeft_Test {
+
+    @Test
+    fun `should fail if either is null`() {
+        // GIVEN
+        val leftValue: Either<Nothing, Nothing>? = null
+        // WHEN/THEN
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(leftValue).isLeft() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(FailureMessages.actualIsNull())
+    }
+
+    @Test
+    fun `should pass if either is left`() {
+        // GIVEN
+        val leftValue = "Error".left()
+        // WHEN/THEN
+        EitherAssert.assertThat(leftValue).isLeft()
+    }
+
+    @Test
+    fun `should fail if either is right`() {
+        // GIVEN
+        val rightValue = 42.right()
+        // WHEN/THEN
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(rightValue).isLeft() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeLeft(rightValue).create())
+    }
+}

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

@@ -3,6 +3,7 @@ package `in`.rcard.assertj.arrowcore
 import arrow.core.Either
 import arrow.core.left
 import arrow.core.right
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeRight.Companion.shouldBeRight
 import org.assertj.core.api.Assertions
 import org.assertj.core.util.FailureMessages.actualIsNull
 import org.junit.jupiter.api.Test
@@ -34,6 +35,6 @@ class EitherAssert_isRight_Test {
         // WHEN/THEN
         Assertions.assertThatThrownBy { EitherAssert.assertThat(leftValue).isRight() }
             .isInstanceOf(AssertionError::class.java)
-            .hasMessage("\nExpected Either to be right but was <Either.Left(42)>")
+            .hasMessage(shouldBeRight(leftValue).create())
     }
 }