Added isEmpty assert to Option type

Author: rcardin

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

@@ -1,6 +1,7 @@
 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 org.assertj.core.api.AbstractObjectAssert
 
@@ -27,4 +28,15 @@ abstract class AbstractOptionAssert<
         if (actual.isEmpty()) throwAssertionError(shouldBePresent())
         return myself
     }
+
+    /**
+     * Verifies that the actual [Option] is empty.
+     *
+     * @return this assertion object.
+     */
+    fun isEmpty(): SELF {
+        isNotNull
+        if (actual.isDefined()) throwAssertionError(shouldBeEmpty(actual))
+        return myself
+    }
 }

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

@@ -29,11 +29,11 @@ internal class EitherShouldContain(message: String, actual: Either<Any, Any>, ex
          */
         internal fun <LEFT : Any, RIGHT : Any> shouldContainOnRight(
             actual: Either<LEFT, RIGHT>,
-            expectedValue: RIGHT
+            expectedValue: RIGHT,
         ): EitherShouldContain = EitherShouldContain(
             EXPECTING_TO_CONTAIN_ON_RIGHT,
             actual,
-            expectedValue
+            expectedValue,
         )
 
         /**
@@ -47,11 +47,11 @@ internal class EitherShouldContain(message: String, actual: Either<Any, Any>, ex
          */
         internal fun <LEFT : Any, RIGHT : Any> shouldContainOnLeft(
             actual: Either<LEFT, RIGHT>,
-            expectedValue: RIGHT
+            expectedValue: RIGHT,
         ): EitherShouldContain = EitherShouldContain(
             EXPECTING_TO_CONTAIN_ON_LEFT,
             actual,
-            expectedValue
+            expectedValue,
         )
     }
 }

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

@@ -0,0 +1,17 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import arrow.core.Option
+import org.assertj.core.error.BasicErrorMessageFactory
+
+/**
+ * Build error message when an [Option] should be empty.
+ *
+ * @author Riccardo Cardin
+ */
+internal class OptionShouldBeEmpty(expected: Option<*>) :
+    BasicErrorMessageFactory("%nExpecting an Option to be empty but was <%s>.", expected.orNull()) {
+    companion object {
+        internal fun shouldBeEmpty(actual: Option<*>): OptionShouldBeEmpty =
+            OptionShouldBeEmpty(actual)
+    }
+}

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

@@ -17,8 +17,6 @@ class OptionShouldBePresent :
          *
          * @return a error message factory.
          */
-        fun shouldBePresent(): OptionShouldBePresent {
-            return OptionShouldBePresent()
-        }
+        fun shouldBePresent(): OptionShouldBePresent = OptionShouldBePresent()
     }
 }

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

@@ -0,0 +1,34 @@
+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.OptionShouldBeEmpty.Companion.shouldBeEmpty
+import org.assertj.core.api.Assertions
+import org.assertj.core.util.FailureMessages
+import org.junit.jupiter.api.Test
+
+internal class OptionAssert_isEmpty_Test {
+
+    @Test
+    internal fun `should pass if Option is empty`() {
+        assertThat(None).isEmpty()
+    }
+
+    @Test
+    internal fun `should fail when Option is null`() {
+        val nullOption: Option<Nothing>? = null
+        Assertions.assertThatThrownBy { assertThat(nullOption).isEmpty() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(FailureMessages.actualIsNull())
+    }
+
+    @Test
+    internal fun `should fail if Option is present`() {
+        val actual: Option<String> = "not-empty".some()
+        Assertions.assertThatThrownBy { assertThat(actual).isEmpty() }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeEmpty(actual).create())
+    }
+}