feat(60): Added the function RaiseAssert.assertThatRaisedBy and its tests

Author: rcardin

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

@@ -4,9 +4,12 @@ package `in`.rcard.assertj.arrowcore
 
 import arrow.core.raise.Raise
 import arrow.core.raise.fold
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailButSucceedsWith
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldThrowAnException.Companion.shouldThrowAnException
+import org.assertj.core.api.AbstractObjectAssert
 import org.assertj.core.api.AbstractThrowableAssert
 import org.assertj.core.api.Assertions
+import org.assertj.core.api.Fail
 import org.assertj.core.internal.Failures
 import kotlin.experimental.ExperimentalTypeInference
 
@@ -57,5 +60,21 @@ class RaiseAssert<ERROR : Any, VALUE : Any>(
                 .instance()
                 .failure(Assertions.assertThat(throwable).writableAssertionInfo, shouldThrowAnException())
         }
+
+        inline fun <ERROR : Any, VALUE : Any> assertThatRaisedBy(
+            @BuilderInference shouldRaiseError: Raise<ERROR>.() -> VALUE,
+        ): AbstractObjectAssert<*, out ERROR> {
+            val error =
+                fold(
+                    block = shouldRaiseError,
+                    recover = { error -> error },
+                    transform = { value ->
+                        Fail.fail(
+                            shouldFailButSucceedsWith(value).create(),
+                        )
+                    },
+                )
+            return Assertions.assertThat(error)
+        }
     }
 }

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

@@ -14,7 +14,7 @@ private const val SHOULD_FAIL_BUT_SUCCEEDS_WITH_MESSAGE: String =
  * @author Riccardo Cardin
  * @since 0.2.0
  */
-internal class RaiseShouldFailButSucceeds private constructor(
+class RaiseShouldFailButSucceeds private constructor(
     expectedError: Any,
     actualSucceededValue: Any,
     message: String,
@@ -26,7 +26,7 @@ internal class RaiseShouldFailButSucceeds private constructor(
         ): RaiseShouldFailButSucceeds =
             RaiseShouldFailButSucceeds(expectedError, actualSucceededValue, SHOULD_FAIL_WITH_BUT_SUCCEEDS_WITH_MESSAGE)
 
-        internal fun shouldFailButSucceedsWith(actualSucceededValue: Any): RaiseShouldFailButSucceeds =
+        fun shouldFailButSucceedsWith(actualSucceededValue: Any): RaiseShouldFailButSucceeds =
             RaiseShouldFailButSucceeds("", actualSucceededValue, SHOULD_FAIL_BUT_SUCCEEDS_WITH_MESSAGE)
     }
 }

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

@@ -12,4 +12,6 @@ internal object Dummy {
     suspend fun Raise<String>.aSuspendFunctionWithContext(input: Int): Int = input
 
     suspend fun Raise<String>.aSuspendFunctionThatThrowsAnException(): Int = throw RuntimeException("AN EXCEPTION")
+
+    suspend fun Raise<String>.aSuspendFunctionThatRaisesAnError(): Int = raise("LOGICAL ERROR")
 }

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

@@ -0,0 +1,40 @@
+package `in`.rcard.assertj.arrowcore
+
+import `in`.rcard.assertj.arrowcore.Dummy.aFunctionThatRaisesAnError
+import `in`.rcard.assertj.arrowcore.Dummy.aFunctionThatThrowsAnException
+import `in`.rcard.assertj.arrowcore.Dummy.aFunctionWithContext
+import `in`.rcard.assertj.arrowcore.Dummy.aSuspendFunctionThatRaisesAnError
+import `in`.rcard.assertj.arrowcore.RaiseAssert.Companion.assertThatRaisedBy
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailButSucceedsWith
+import kotlinx.coroutines.test.runTest
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+class RaiseAssert_assertThatRaisedBy_Test {
+    @Test
+    internal fun `should return a valid Object Assert if the Raise raises an error`() {
+        assertThatRaisedBy { aFunctionThatRaisesAnError() }.isEqualTo("LOGICAL ERROR")
+    }
+
+    @Test
+    fun `should work with suspended functions`() =
+        runTest {
+            assertThatRaisedBy { aSuspendFunctionThatRaisesAnError() }.isEqualTo("LOGICAL ERROR")
+        }
+
+    @Test
+    internal fun `should fails if the Raise returns a value`() {
+        Assertions
+            .assertThatThrownBy { assertThatRaisedBy { aFunctionWithContext(42) } }
+            .isInstanceOf(AssertionError::class.java)
+            .hasMessage(shouldFailButSucceedsWith(42).create())
+    }
+
+    @Test
+    internal fun `should rethrow the inner exception`() {
+        Assertions
+            .assertThatThrownBy { assertThatRaisedBy { aFunctionThatThrowsAnException() } }
+            .isInstanceOf(RuntimeException::class.java)
+            .hasMessage("AN EXCEPTION")
+    }
+}

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

@@ -1,5 +1,6 @@
 package `in`.rcard.assertj.arrowcore
 
+import arrow.core.raise.Raise
 import `in`.rcard.assertj.arrowcore.Dummy.aFunctionThatRaisesAnError
 import `in`.rcard.assertj.arrowcore.Dummy.aFunctionThatThrowsAnException
 import `in`.rcard.assertj.arrowcore.Dummy.aFunctionWithContext
@@ -29,4 +30,17 @@ internal class RaiseAssert_result_Test {
             .isInstanceOf(RuntimeException::class.java)
             .hasMessage("AN EXCEPTION")
     }
+
+    @Test
+    fun lordOfTheRings() {
+        val hobbits: Raise<String>.() -> List<String> = { listOf("Frodo", "Samwise", "Peregrin", "Meriadoc") }
+        assertThat(hobbits).succeedsWith(listOf("Frodo", "Samwise", "Peregrin", "Meriadoc"))
+
+        assertThat(hobbits).result().satisfies({
+            Assertions.assertThat(it).hasSize(4)
+        })
+
+        val dwarves: Raise<String>.() -> List<String> = { raise("No dwarves here!") }
+        assertThat(dwarves).error().isEqualTo("No dwarves here!")
+    }
 }