Merge pull request #15 from sFreezer/satisfying

Add satisfying fun

Author: rcardin

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

@@ -10,6 +10,7 @@ import `in`.rcard.assertj.arrowcore.errors.EitherShouldContainInstanceOf.Compani
 import org.assertj.core.api.AbstractObjectAssert
 import org.assertj.core.internal.ComparisonStrategy
 import org.assertj.core.internal.StandardComparisonStrategy
+import java.util.function.Consumer
 
 /**
  * Assertions for [Either].
@@ -81,6 +82,17 @@ abstract class AbstractEitherAssert<
         return myself
     }
 
+    /**
+     * Verifies that the actual [Either] contains a right-sided value and gives this value to the given
+     * consumer for further assertions. Should be used as a way of deeper asserting on the
+     * containing object, as further requirement(s) for the value.
+     */
+    fun hasRightValueSatisfying(requirement: (RIGHT) -> Unit): SELF {
+        assertIsRight()
+        actual.onRight { requirement(it) }
+        return myself
+    }
+
     private fun assertIsRight() {
         isNotNull
         if (!actual.isRight()) {
@@ -114,6 +126,17 @@ abstract class AbstractEitherAssert<
         return myself
     }
 
+    /**
+     * Verifies that the actual [Either] contains a left-sided value and gives this value to the given
+     * consumer for further assertions. Should be used as a way of deeper asserting on the
+     * containing object, as further requirement(s) for the value.
+     */
+    fun hasLeftValueSatisfying(requirement: (LEFT) -> Unit): SELF {
+        assertIsLeft()
+        actual.onLeft { requirement(it) }
+        return myself
+    }
+
     private fun assertIsLeft() {
         isNotNull
         if (!actual.isLeft()) {

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

@@ -8,6 +8,7 @@ import `in`.rcard.assertj.arrowcore.errors.OptionShouldContainInstanceOf.Compani
 import org.assertj.core.api.AbstractObjectAssert
 import org.assertj.core.internal.ComparisonStrategy
 import org.assertj.core.internal.StandardComparisonStrategy
+import java.util.function.Consumer
 
 /**
  * Assertions for [Option].
@@ -85,6 +86,20 @@ abstract class AbstractOptionAssert<
         return myself
     }
 
+    /**
+     * Verifies that the actual [Option] contains a value and gives this value to the given
+     * consumer for further assertions. Should be used as a way of deeper asserting on the
+     * containing object, as further requirement(s) for the value.
+     *
+     * @param requirement to further assert on the object contained inside the [Option].
+     * @return this assertion object.
+     */
+    fun hasValueSatisfying(requirement: (VALUE) -> Unit): SELF {
+        assertValueIsPresent()
+        actual.onSome { requirement(it) }
+        return myself
+    }
+
     private fun assertValueIsPresent() {
         isNotNull
         if (actual.isEmpty()) throwAssertionError(shouldBePresent())

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

@@ -0,0 +1,42 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.Either
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeLeft
+import org.assertj.core.api.Assertions
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.util.FailureMessages.actualIsNull
+import org.junit.jupiter.api.Test
+
+
+internal class EitherAssert_hasLeftValueSatisfying_Test {
+
+    @Test
+    internal fun `should fail when either is null`() {
+        val actual: Either<Int, String>? = null
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).hasLeftValueSatisfying { } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(actualIsNull())
+    }
+
+    @Test
+    internal fun `should fail if either is right`() {
+        val actual: Either<Int, String> = Either.Right("something")
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).hasLeftValueSatisfying { } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(EitherShouldBeLeft.shouldBeLeft(actual).create())
+    }
+
+    @Test
+    internal fun `should fail if consumer fails`() {
+        val actual: Either<Int, String> = Either.Left(42)
+        Assertions.assertThatThrownBy { EitherAssert.assertThat(actual).hasRightValueSatisfying { assertThat(it).isEqualTo(24) } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(("\nexpected: \"24\"\n but was: \"42\""))
+    }
+
+    @Test
+    internal fun `should pass if consumer passes`() {
+        val actual: Either<Int, String> = Either.Left(42)
+        EitherAssert.assertThat(actual).hasLeftValueSatisfying { assertThat(it).isEqualTo(42) }
+    }
+}

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

@@ -0,0 +1,42 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.Either
+import `in`.rcard.assertj.arrowcore.errors.EitherShouldBeRight.Companion.shouldBeRight
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.assertj.core.util.FailureMessages.actualIsNull
+import org.junit.jupiter.api.Test
+
+
+internal class EitherAssert_hasRightValueSatisfying_Test {
+
+    @Test
+    internal fun `should fail when either is null`() {
+        val actual: Either<Int, String>? = null
+        assertThatThrownBy { EitherAssert.assertThat(actual).hasRightValueSatisfying { } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(actualIsNull())
+    }
+
+    @Test
+    internal fun `should fail if either is left`() {
+        val actual: Either<Int, String> = Either.Left(42)
+        assertThatThrownBy { EitherAssert.assertThat(actual).hasRightValueSatisfying { } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldBeRight(actual).create())
+    }
+
+    @Test
+    internal fun `should fail if consumer fails`() {
+        val actual: Either<Int, String> = Either.Right("something")
+        assertThatThrownBy { EitherAssert.assertThat(actual).hasRightValueSatisfying { assertThat(it).isEqualTo("something else") } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(("\nexpected: \"something else\"\n but was: \"something\""))
+    }
+
+    @Test
+    internal fun `should pass if consumer passes`() {
+        val actual: Either<Int, String> = Either.Right("something")
+        EitherAssert.assertThat(actual).hasRightValueSatisfying { assertThat(it).isEqualTo("something") }
+    }
+}

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

@@ -0,0 +1,56 @@
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.None
+import arrow.core.Option
+import `in`.rcard.assertj.arrowcore.OptionAssert.Companion.assertThat
+import `in`.rcard.assertj.arrowcore.errors.OptionShouldBePresent.Companion.shouldBePresent
+import org.assertj.core.api.Assertions.assertThat
+import org.assertj.core.api.Assertions.assertThatThrownBy
+import org.assertj.core.util.FailureMessages.actualIsNull
+import org.junit.jupiter.api.Test
+
+
+internal class OptionAssert_hasValueSatisfying_Test {
+
+    @Test
+    internal fun `should fail when option is null`() {
+        assertThatThrownBy {
+            val nullOption: Option<String>? = null
+            assertThat(nullOption).hasValueSatisfying { }
+        }
+        .isInstanceOf(AssertionError::class.java)
+        .hasMessage(actualIsNull())
+    }
+
+    @Test
+    internal fun `should fail when option is none`() {
+        assertThatThrownBy {
+            assertThat(None).hasValueSatisfying { }
+        }
+        .isInstanceOf(AssertionError::class.java)
+        .hasMessage(shouldBePresent().create())
+    }
+
+
+    @Test
+    internal fun `should pass when consumer passes`() {
+        assertThat(Option("something")).hasValueSatisfying {
+            assertThat(it).isEqualTo("something")
+                .startsWith("some")
+                .endsWith("thing")
+        }
+        assertThat(Option(10)).hasValueSatisfying {
+            assertThat(it).isGreaterThan(9)
+        }
+    }
+
+    @Test
+    internal fun `should fail from consumer`() {
+        assertThatThrownBy {
+            assertThat(Option("something"))
+                .hasValueSatisfying { assertThat(it).isEqualTo("something else") }
+        }
+        .isInstanceOf(AssertionError::class.java)
+        .hasMessage("\nexpected: \"something else\"\n but was: \"something\"")
+    }
+}