Added the containsOnRight assertion

Author: rcardin-lm

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

@@ -3,29 +3,32 @@ 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 `in`.rcard.assertj.arrowcore.errors.EitherShouldContain.Companion.shouldContainOnRight
 import org.assertj.core.api.AbstractObjectAssert
+import org.assertj.core.internal.ComparisonStrategy
+import org.assertj.core.internal.StandardComparisonStrategy
 
 /**
  * Assertions for [Either].
  *
- * @param <SELF>  the "self" type of this assertion class.
- * @param <LEFT>  type of the left value contained in the [Either].
- * @param <RIGHT> type of the right value contained in the [Either].
+ * @param SELF  the "self" type of this assertion class.
+ * @param LEFT  type of the left value contained in the [Either].
+ * @param RIGHT type of the right value contained in the [Either].
  * @author Riccardo Cardin
  */
-abstract class AbstractEitherAssert<SELF : AbstractEitherAssert<SELF, LEFT, RIGHT>, LEFT, RIGHT>(either: Either<LEFT, RIGHT>?) :
+abstract class AbstractEitherAssert<SELF : AbstractEitherAssert<SELF, LEFT, RIGHT>, LEFT : Any, RIGHT : Any>(either: Either<LEFT, RIGHT>?) :
     AbstractObjectAssert<SELF, Either<LEFT, RIGHT>>(either, AbstractEitherAssert::class.java) {
 
+    private val comparisonStrategy: ComparisonStrategy = StandardComparisonStrategy.instance()
+
     /**
      * Verifies that the actual [Either] is right.
      *
      * @return this assertion object.
      */
     fun isRight(): SELF {
         isNotNull
-        if (!actual.isRight()) {
-            throwAssertionError(shouldBeRight(actual))
-        }
+        assertIsRight()
         return myself
     }
 
@@ -35,10 +38,31 @@ abstract class AbstractEitherAssert<SELF : AbstractEitherAssert<SELF, LEFT, RIGH
      * @return this assertion object.
      */
     fun isLeft(): SELF {
+        assertIsLeft()
+        return myself
+    }
+
+    private fun assertIsLeft() {
         isNotNull
         if (!actual.isLeft()) {
             throwAssertionError(shouldBeLeft(actual))
         }
+    }
+
+    fun containsOnRight(expectedValue: RIGHT): SELF {
+        assertIsRight()
+        actual.onRight { right ->
+            if (!comparisonStrategy.areEqual(right, expectedValue)) throwAssertionError(
+                shouldContainOnRight(actual, expectedValue)
+            )
+        }
         return myself
     }
+
+    private fun assertIsRight() {
+        isNotNull
+        if (!actual.isRight()) {
+            throwAssertionError(shouldBeRight(actual))
+        }
+    }
 }

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

@@ -5,14 +5,14 @@ import arrow.core.Either
 /**
  * Assertions for [Either].
  *
- * @param <LEFT>  type of the value on the left contained in the [Either].
- * @param <RIGHT> type of the value on the right contained in the [Either].
+ * @param LEFT  type of the value on the left contained in the [Either].
+ * @param RIGHT type of the value on the right contained in the [Either].
  * @author Riccardo Cardin
  */
-class EitherAssert<LEFT, RIGHT>(either: Either<LEFT, RIGHT>?) :
+class EitherAssert<LEFT : Any, RIGHT : Any>(either: Either<LEFT, RIGHT>?) :
     AbstractEitherAssert<EitherAssert<LEFT, RIGHT>, LEFT, RIGHT>(either) {
     companion object {
-        fun <LEFT, RIGHT> assertThat(actual: Either<LEFT, RIGHT>?): EitherAssert<LEFT, RIGHT> {
+        fun <LEFT : Any, RIGHT : Any> assertThat(actual: Either<LEFT, RIGHT>?): EitherAssert<LEFT, RIGHT> {
             return EitherAssert(actual)
         }
     }

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

@@ -11,8 +11,6 @@ import org.assertj.core.error.BasicErrorMessageFactory
 class EitherShouldBeLeft(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be left but was <$actual>.") {
     companion object {
-        fun shouldBeLeft(actual: Either<*, *>): EitherShouldBeLeft {
-            return EitherShouldBeLeft(actual)
-        }
+        fun shouldBeLeft(actual: Either<*, *>): EitherShouldBeLeft = EitherShouldBeLeft(actual)
     }
 }

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

@@ -11,8 +11,6 @@ import org.assertj.core.error.BasicErrorMessageFactory
 class EitherShouldBeRight(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be right but was <$actual>.") {
     companion object {
-        fun shouldBeRight(actual: Either<*, *>): EitherShouldBeRight {
-            return EitherShouldBeRight(actual)
-        }
+        fun shouldBeRight(actual: Either<*, *>): EitherShouldBeRight = EitherShouldBeRight(actual)
     }
 }

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

@@ -0,0 +1,37 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Either
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build error message when an [Either] should contain a specific value.
+ *
+ * @author Riccardo Cardin
+ */
+class EitherShouldContain(message: String, actual: Either<Any, Any>, expected: Any) :
+    BasicErrorMessageFactory(message, actual, expected) {
+
+    companion object {
+
+        private const val EXPECTING_TO_CONTAIN_ON_RIGHT =
+            "%nExpecting:%n  <%s>%nto contain:%n  <%s> on the [RIGHT]%nbut did not."
+
+        /**
+         * Indicates that the provided [Either] does not contain the provided argument as right value.
+         *
+         * @param actual        the [Either] which contains a value.
+         * @param expectedValue the value we expect to be in the provided [Either] on the right side.
+         * @param LEFT          the type of the value contained in the [Either] on the left side.
+         * @param RIGHT         the type of the value contained in the [Either] on the right side.
+         * @return an error message factory
+         */
+        fun <LEFT : Any, RIGHT : Any> shouldContainOnRight(
+            actual: Either<LEFT, RIGHT>,
+            expectedValue: RIGHT
+        ): EitherShouldContain = EitherShouldContain(
+            EXPECTING_TO_CONTAIN_ON_RIGHT,
+            actual,
+            expectedValue
+        )
+    }
+}

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

@@ -0,0 +1,48 @@
+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 `in`.rcard.assertj.arrowcore.errors.EitherShouldContain.Companion.shouldContainOnRight
+import org.assertj.core.api.Assertions
+import org.assertj.core.util.FailureMessages.actualIsNull
+import org.junit.jupiter.api.Test
+
+class EitherAssert_containsOnRight_Test {
+    @Test
+    fun `should fail when either is null`() {
+        val rightValue: Either<Nothing, String>? = null
+        Assertions.assertThatThrownBy {
+            EitherAssert.assertThat(rightValue).containsOnRight(
+                "something"
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(actualIsNull())
+    }
+
+    @Test
+    fun `should pass if either contains expected value on right side`() {
+        val rightValue = "something".right()
+        EitherAssert.assertThat(rightValue).containsOnRight("something")
+    }
+
+    @Test
+    fun should_fail_if_either_is_left() {
+        val actual: Either<String, String> = "nothing".left()
+        val expectedValue = "something"
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).containsOnRight(expectedValue) }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actual).create())
+    }
+
+    @Test
+    fun `should fail if either does not contain expected value on right side`() {
+        val actual: Either<Nothing, String> = "something".right()
+        val expectedValue = "nothing"
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).containsOnRight(expectedValue) }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldContainOnRight(actual, expectedValue).create())
+    }
+}