WIP Adding containsOnRightInstanceOf

Author: rcardin

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

@@ -69,8 +69,7 @@ abstract class AbstractEitherAssert<
   }
 
   /**
-   * Verifies that the actual [Either] is [Either.Left]
-   * and contains the given value.
+   * Verifies that the actual [Either] is [Either.Left] and contains the given value.
    *
    * @param expectedValue the expected value inside the [Either].
    * @return this assertion object.
@@ -91,4 +90,17 @@ abstract class AbstractEitherAssert<
       throwAssertionError(shouldBeLeft(actual))
     }
   }
+
+  /**
+   * Verifies that the actual right-sided [Either] contains a value that is an
+   * instance of the argument.
+   *
+   * @param expectedClass the expected class of the value inside the right-sided [Either].
+   * @return this assertion object.
+   */
+  fun containsRightInstanceOf(expectedClass: Class<*>): SELF {
+    isNotNull
+    isRight()
+    return myself
+  }
 }

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

@@ -0,0 +1,36 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Either
+import org.assertj.core.error.BasicErrorMessageFactory
+
+class EitherShouldContainInstanceOf(message: String) : BasicErrorMessageFactory(message) {
+  companion object {
+    private const val EXPECTING_TO_CONTAIN_DIFFERENT_INSTANCE =
+        "%nExpecting:%n <%s>%nto contain a value that is an instance of:%n <%s>%nbut did contain an instance of:%n <%s>"
+
+    /**
+     * Indicates that a value should be present in a right-sided [Either].
+     *
+     * @param actual Either to be checked.
+     * @param expectedClass expected class of a right value
+     * @return an error message factory.
+     * @throws java.lang.NullPointerException if either is null.
+     */
+    fun shouldContainOnRightInstanceOf(
+        actual: Either<*, *>,
+        expectedClass: Class<*>
+    ): EitherShouldContainInstanceOf? {
+        actual.onRight { rightValue ->
+            return EitherShouldContainInstanceOf(
+                java.lang.String.format(
+                    EXPECTING_TO_CONTAIN_DIFFERENT_INSTANCE,
+                    actual.javaClass.simpleName,
+                    expectedClass.name,
+                    rightValue.javaClass.name
+                ))
+        }.onLeft {
+            TODO()
+        }
+    }
+  }
+}

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

@@ -0,0 +1,58 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.Either
+import arrow.core.left
+import arrow.core.right
+import `in`.rcard.assertj.arrowcore.EitherAssert.Companion.assertThat
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeRight.Companion.shouldBeRight
+import org.assertj.core.api.Assertions
+import org.assertj.core.util.FailureMessages
+import org.junit.jupiter.api.Test
+
+class EitherAssert_containsOnRightInstanceOf_Test {
+
+    @Test
+    fun `should fail if either is null`() {
+        val actual: Either<Nothing, Nothing>? = null
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsRightInstanceOf(
+                Any::class.java
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(FailureMessages.actualIsNull())
+    }
+
+    @Test
+    fun `should fail if either is left`() {
+        val actual: Either<String, Nothing> = "some".left()
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsRightInstanceOf(
+                Any::class.java
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actual).create())
+    }
+
+    @Test
+    fun should_fail_if_either_contains_other_type_on_right_than_required() {
+        val actual: Either<Any, Int> = 42.right()
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsRightInstanceOf(String::class.java)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(
+                shouldContainOnRightInstanceOf(
+                    actual,
+                    Int::class.java,
+                ).create()
+            )
+    }
+
+    @Test
+    fun `should pass if either contains required type on right`() {
+        val actual: Either<Nothing, String> = "something".right()
+        assertThat(actual).containsRightInstanceOf(String::class.java)
+    }
+}