Added shouldContainsInstanceOf assertion to OptionAssert

Author: rcardin

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

@@ -4,6 +4,7 @@ import arrow.core.Option
 import `in`.rcard.assertj.arrowcore.errors.OptionShouldBeEmpty.Companion.shouldBeEmpty
 import `in`.rcard.assertj.arrowcore.errors.OptionShouldBePresent.Companion.shouldBePresent
 import `in`.rcard.assertj.arrowcore.errors.OptionShouldContain.Companion.shouldContain
+import `in`.rcard.assertj.arrowcore.errors.OptionShouldContainInstanceOf.Companion.shouldContainInstanceOf
 import org.assertj.core.api.AbstractObjectAssert
 import org.assertj.core.internal.ComparisonStrategy
 import org.assertj.core.internal.StandardComparisonStrategy
@@ -29,8 +30,7 @@ abstract class AbstractOptionAssert<
      * @return this assertion object.
      */
     fun isDefined(): SELF {
-        isNotNull
-        if (actual.isEmpty()) throwAssertionError(shouldBePresent())
+        assertValueIsPresent()
         return myself
     }
 
@@ -63,4 +63,30 @@ abstract class AbstractOptionAssert<
         )
         return myself
     }
+
+    /**
+     * Verifies that the actual [Option] contains a value that is an instance of the argument.
+     *
+     * @param expectedClass the expected class of the value inside the [Option].
+     * @return this assertion object.
+     */
+    fun containsInstanceOf(expectedClass: Class<*>): SELF {
+        assertValueIsPresent()
+        actual.tap { value ->
+            if (!expectedClass.isInstance(value)) {
+                throwAssertionError(
+                    shouldContainInstanceOf(
+                        actual,
+                        expectedClass,
+                    ),
+                )
+            }
+        }
+        return myself
+    }
+
+    private fun assertValueIsPresent() {
+        isNotNull
+        if (actual.isEmpty()) throwAssertionError(shouldBePresent())
+    }
 }

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

@@ -0,0 +1,45 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Option
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build an error message when a value should be instance of a specific class.
+ *
+ * @author Riccardo Cardin
+ */
+internal class OptionShouldContainInstanceOf(message: String) : BasicErrorMessageFactory(message) {
+
+    companion object {
+        /**
+         * Indicates that a value of a specific class should be present in an empty [Option].
+         *
+         * @param option Option to be checked.
+         * @param clazz expected class of a value
+         * @return an error message factory.
+         * @throws java.lang.NullPointerException if option is null.
+         */
+        internal fun <VALUE : Any> shouldContainInstanceOf(
+            option: Option<VALUE>,
+            clazz: Class<*>,
+        ): OptionShouldContainInstanceOf = option.fold(
+            {
+                OptionShouldContainInstanceOf(
+                    "%nExpecting:%n <%s>%nto contain a value that is an instance of:%n <%s>%nbut was empty".format(
+                        option,
+                        clazz.name,
+                    ),
+                )
+            },
+            { value ->
+                OptionShouldContainInstanceOf(
+                    "%nExpecting:%n <%s>%nto contain a value that is an instance of:%n <%s>%nbut did contain an instance of:%n <%s>".format(
+                        option,
+                        clazz.name,
+                        value.javaClass.name,
+                    ),
+                )
+            },
+        )
+    }
+}

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

@@ -0,0 +1,58 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.None
+import arrow.core.Option
+import arrow.core.some
+import `in`.rcard.assertj.arrowcore.OptionAssert.Companion.assertThat
+import `in`.rcard.assertj.arrowcore.errors.OptionShouldBePresent.Companion.shouldBePresent
+import `in`.rcard.assertj.arrowcore.errors.OptionShouldContainInstanceOf.Companion.shouldContainInstanceOf
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+internal class OptionAssert_containsInstanceOf_Test {
+
+    @Test
+    internal fun `should fail if option is empty`() {
+        val actual: Option<Any> = None
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsInstanceOf(
+                Any::class.java,
+            )
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBePresent().create())
+    }
+
+    @Test
+    internal fun `should pass if option contains required type`() {
+        val optionValue = "something".some()
+        assertThat(optionValue).containsInstanceOf(String::class.java)
+    }
+
+    @Test
+    internal fun `should pass if option contains required type subclass`() {
+        val optionValue = Child().some()
+        assertThat(optionValue).containsInstanceOf(
+            Parent::class.java,
+        )
+    }
+
+    @Test
+    internal fun `should fail if option contains other type than required`() {
+        val actual = 42.some()
+        Assertions.assertThatThrownBy {
+            assertThat(actual).containsInstanceOf(String::class.java)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(
+                shouldContainInstanceOf(
+                    actual,
+                    String::class.java,
+                ).create(),
+            )
+    }
+
+    private open class Parent
+
+    private class Child : Parent()
+}