Added shouldContains assertion to OptionAssert

Author: rcardin

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

@@ -3,7 +3,10 @@ package `in`.rcard.assertj.arrowcore
 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 org.assertj.core.api.AbstractObjectAssert
+import org.assertj.core.internal.ComparisonStrategy
+import org.assertj.core.internal.StandardComparisonStrategy
 
 /**
  * Assertions for [Option].
@@ -18,6 +21,8 @@ abstract class AbstractOptionAssert<
     option: Option<VALUE>?,
 ) : AbstractObjectAssert<SELF, Option<VALUE>>(option, AbstractOptionAssert::class.java) {
 
+    private val comparisonStrategy: ComparisonStrategy = StandardComparisonStrategy.instance()
+
     /**
      * Verifies that there is a value present in the actual [Option].
      *
@@ -39,4 +44,23 @@ abstract class AbstractOptionAssert<
         if (actual.isDefined()) throwAssertionError(shouldBeEmpty(actual))
         return myself
     }
+
+    /**
+     * Verifies that the actual [Option] contains the given value.
+     *
+     * @param expectedValue the expected value inside the [Option].
+     * @return this assertion object.
+     */
+    fun contains(expectedValue: VALUE): SELF {
+        isNotNull
+        actual.fold(
+            { throwAssertionError(shouldContain(actual, expectedValue)) },
+            { actualValue ->
+                if (!comparisonStrategy.areEqual(actualValue, expectedValue)) {
+                    throwAssertionError(shouldContain(actual, expectedValue))
+                }
+            },
+        )
+        return myself
+    }
 }

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

@@ -0,0 +1,43 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Option
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build error message when an [Option] should contain a specific value.
+ *
+ * @author Riccardo Cardin
+ */
+internal class OptionShouldContain(message: String, vararg objs: Any) :
+    BasicErrorMessageFactory(message, *objs) {
+
+    companion object {
+        private const val EXPECTING_TO_CONTAIN =
+            "%nExpecting:%n  <%s>%nto contain:%n  <%s>%nbut did not."
+        private const val EXPECTING_TO_CONTAIN_BUT_WAS_EMPTY =
+            "%nExpecting Option to contain:%n  <%s>%nbut was empty."
+
+        /**
+         * Indicates that the provided [Option] does not contain the provided argument.
+         *
+         * @param VALUE      the type of the value contained in the [Option].
+         * @param option        the [Option] which contains a value.
+         * @param expectedValue the value we expect to be in the provided [Option].
+         * @return an error message factory
+         */
+        internal fun <VALUE : Any> shouldContain(
+            option: Option<VALUE>,
+            expectedValue: VALUE,
+        ): OptionShouldContain =
+            option.fold(
+                { OptionShouldContain(EXPECTING_TO_CONTAIN_BUT_WAS_EMPTY, expectedValue) },
+                { _ ->
+                    OptionShouldContain(
+                        EXPECTING_TO_CONTAIN,
+                        option,
+                        expectedValue,
+                    )
+                },
+            )
+    }
+}

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

@@ -0,0 +1,48 @@
+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.OptionShouldContain.Companion.shouldContain
+import org.assertj.core.api.Assertions
+import org.assertj.core.util.FailureMessages
+import org.junit.jupiter.api.Test
+
+internal class OptionAssert_contains_Test {
+
+    @Test
+    internal fun `should fail when option is null`() {
+        Assertions.assertThatThrownBy {
+            val nullOption: Option<String>? = null
+            assertThat(nullOption).contains("something")
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(FailureMessages.actualIsNull())
+    }
+
+    @Test
+    internal fun `should pass if option contains expected value`() {
+        assertThat("something".some()).contains("something")
+    }
+
+    @Test
+    internal fun `should fail if option does not contain expected value`() {
+        val actual: Option<String> = "not-expected".some()
+        val expectedValue = "something"
+        Assertions.assertThatThrownBy { assertThat(actual).contains(expectedValue) }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldContain(actual, expectedValue).create())
+    }
+
+    @Test
+    internal fun `should fail if option is empty`() {
+        val expectedValue = "something"
+        val emptyOption: Option<String> = None
+        Assertions.assertThatThrownBy {
+            assertThat(emptyOption).contains(expectedValue)
+        }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldContain(emptyOption, expectedValue).create())
+    }
+}