fix(49): Moved Raise evaluation into the 'assertThat' function

rcardin · rcardin · commit 6b6e9a444957 · 2024-08-27T08:39:28.000+02:00
diff --git a/src/main/kotlin/in/rcard/assertj/arrowcore/AbstractRaiseAssert.kt b/src/main/kotlin/in/rcard/assertj/arrowcore/AbstractRaiseAssert.kt
@@ -2,9 +2,11 @@ package `in`.rcard.assertj.arrowcore
 
 import arrow.core.raise.Raise
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailButSucceedsWith
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailWithButSucceedsWith
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailWith.Companion.shouldFailWith
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedButFailed.Companion.shouldSucceedButFailed
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedWith.Companion.shouldSucceedWith
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedWithButFailed.Companion.shouldSucceedWithButFailed
 import org.assertj.core.api.AbstractAssert
 import org.assertj.core.internal.ComparisonStrategy
 import org.assertj.core.internal.StandardComparisonStrategy
@@ -33,104 +35,104 @@ abstract class AbstractRaiseAssert<
      * Verifies that the function in the [Raise] context succeeds with the given value.
      * @param expectedValue the expected value returned by the function.
      */
-    fun succeedsWith(expectedValue: VALUE) {
+    fun succeedsWith(expectedValue: VALUE) =
         when (actual) {
             is RaiseResult.Failure<ERROR> -> {
                 throwAssertionError(
-                    shouldSucceedButFailed((actual as RaiseResult.Failure<ERROR>).error),
+                    shouldSucceedWithButFailed(expectedValue, (actual as RaiseResult.Failure<ERROR>).error),
                 )
             }
 
             is RaiseResult.FailureWithException -> {
-                // TODO: Add a specific error message
+                throw (actual as RaiseResult.FailureWithException).exception
             }
 
             is RaiseResult.Success<VALUE> -> {
                 val actualValue = (actual as RaiseResult.Success<VALUE>).value
                 if (!comparisonStrategy.areEqual(actualValue, expectedValue)) {
                     throwAssertionError(shouldSucceedWith(expectedValue, actualValue))
+                } else {
+                    // Nothing to do
                 }
             }
         }
-    }
 
     /**
      * Verifies that the function in the [Raise] context succeeded. No check on the value returned by the function is
      * performed.
      *
      * @see succeedsWith
      */
-    fun succeeds() {
+    fun succeeds() =
         when (actual) {
             is RaiseResult.Failure<ERROR> ->
                 throwAssertionError(
                     shouldSucceedButFailed((actual as RaiseResult.Failure<ERROR>).error),
                 )
 
             is RaiseResult.FailureWithException -> {
-                // TODO: Add a specific error message
+                throw (actual as RaiseResult.FailureWithException).exception
             }
 
             is RaiseResult.Success<VALUE> -> {
                 // Nothing to do
             }
         }
-    }
 
     /**
      * Verifies that the function in the [Raise] context fails with the given error.
      * @param expectedError the expected error raised by the function.
      */
-    fun raises(expectedError: ERROR) {
+    fun raises(expectedError: ERROR) =
         when (actual) {
             is RaiseResult.Failure<ERROR> -> {
                 val actualError = (actual as RaiseResult.Failure<ERROR>).error
                 if (!comparisonStrategy.areEqual(actualError, expectedError)) {
                     throwAssertionError(shouldFailWith(expectedError, actualError))
+                } else {
+                    // Nothing to do
                 }
             }
 
             is RaiseResult.FailureWithException -> {
-                // TODO: Add a specific error message
+                throw (actual as RaiseResult.FailureWithException).exception
             }
 
             is RaiseResult.Success<VALUE> -> {
                 throwAssertionError(
-                    shouldFailButSucceedsWith((actual as RaiseResult.Success<VALUE>).value),
+                    shouldFailWithButSucceedsWith(expectedError, (actual as RaiseResult.Success<VALUE>).value),
                 )
             }
         }
-    }
 
     /**
      * Verifies that the function in the [Raise] context fails, no matter the type of the logical error.
      *
      * @see raises
      */
-    fun fails() {
+    fun fails() =
         when (actual) {
             is RaiseResult.Failure<ERROR> -> {
                 // Nothing to do
             }
 
             is RaiseResult.FailureWithException -> {
-                // TODO: Add a specific error message
+                throw (actual as RaiseResult.FailureWithException).exception
             }
 
             is RaiseResult.Success ->
                 throwAssertionError(
                     shouldFailButSucceedsWith((actual as RaiseResult.Success<VALUE>).value),
                 )
         }
-    }
 }
 
-sealed interface RaiseResult<ERROR : Any, VALUE : Any> {
-    data class Success<VALUE : Any>(
+sealed interface RaiseResult<out ERROR : Any, out VALUE : Any> {
+    data class Success<out VALUE : Any>(
         val value: VALUE,
     ) : RaiseResult<Nothing, VALUE>
 
-    data class Failure<ERROR : Any>(
+    data class Failure<out ERROR : Any>(
         val error: ERROR,
     ) : RaiseResult<ERROR, Nothing>
 
diff --git a/src/main/kotlin/in/rcard/assertj/arrowcore/RaiseAssert.kt b/src/main/kotlin/in/rcard/assertj/arrowcore/RaiseAssert.kt
@@ -25,7 +25,7 @@ class RaiseAssert<ERROR : Any, VALUE : Any>(
     companion object {
         inline fun <ERROR : Any, VALUE : Any> assertThat(
             @BuilderInference lambda: Raise<ERROR>.() -> VALUE,
-        ): RaiseAssert<out ERROR, out VALUE> {
+        ): RaiseAssert<ERROR, VALUE> {
             val raiseResult =
                 fold(
                     block = lambda,
@@ -41,7 +41,7 @@ class RaiseAssert<ERROR : Any, VALUE : Any>(
          * @param shouldRaiseThrowable the function to be executed in the [Raise] context.
          * @return the [AbstractThrowableAssert] to be used to verify the exception.
          */
-        fun <ERROR : Any, VALUE : Any> assertThatThrownBy(
+        inline fun <ERROR : Any, VALUE : Any> assertThatThrownBy(
             @BuilderInference shouldRaiseThrowable: Raise<ERROR>.() -> VALUE,
         ): AbstractThrowableAssert<*, out Throwable> {
             val throwable: Throwable? =
diff --git a/src/main/kotlin/in/rcard/assertj/arrowcore/errors/RaiseShouldThrowAnException.kt b/src/main/kotlin/in/rcard/assertj/arrowcore/errors/RaiseShouldThrowAnException.kt
@@ -10,11 +10,8 @@ private const val SHOULD_THROW_AN_EXCEPTION_MESSAGE = "%nExpecting code to throw
  * @author Riccardo Cardin
  * @since 0.2.0
  */
-internal class RaiseShouldThrowAnException private constructor() :
-    BasicErrorMessageFactory(SHOULD_THROW_AN_EXCEPTION_MESSAGE) {
-
+class RaiseShouldThrowAnException private constructor() : BasicErrorMessageFactory(SHOULD_THROW_AN_EXCEPTION_MESSAGE) {
     companion object {
-        internal fun shouldThrowAnException(): RaiseShouldThrowAnException =
-            RaiseShouldThrowAnException()
+        fun shouldThrowAnException(): RaiseShouldThrowAnException = RaiseShouldThrowAnException()
     }
-}
+}
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/Dummy.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/Dummy.kt
@@ -10,4 +10,6 @@ internal object Dummy {
     fun Raise<String>.aFunctionThatThrowsAnException(): Int = throw RuntimeException("AN EXCEPTION")
 
     suspend fun Raise<String>.aSuspendFunctionWithContext(input: Int): Int = input
+
+    suspend fun Raise<String>.aSuspendFunctionThatThrowsAnException(): Int = throw RuntimeException("AN EXCEPTION")
 }
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/RaiseAssert_assertThatThrownBy_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/RaiseAssert_assertThatThrownBy_Test.kt
@@ -3,8 +3,10 @@ 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.aSuspendFunctionThatThrowsAnException
 import `in`.rcard.assertj.arrowcore.RaiseAssert.Companion.assertThatThrownBy
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldThrowAnException.Companion.shouldThrowAnException
+import kotlinx.coroutines.test.runTest
 import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
@@ -16,6 +18,14 @@ internal class RaiseAssert_assertThatThrownBy_Test {
             .hasMessage("AN EXCEPTION")
     }
 
+    @Test
+    internal fun `should succeed if the suspending lambda throws an exception`() =
+        runTest {
+            assertThatThrownBy { aSuspendFunctionThatThrowsAnException() }
+                .isInstanceOf(RuntimeException::class.java)
+                .hasMessage("AN EXCEPTION")
+        }
+
     @Test
     internal fun `should fail if the lambda succeeds with a value`() {
         Assertions
diff --git a/src/test/kotlin/in/rcard/assertj/arrowcore/RaiseAssert_assertThat_Test.kt b/src/test/kotlin/in/rcard/assertj/arrowcore/RaiseAssert_assertThat_Test.kt
@@ -14,7 +14,7 @@ internal class RaiseAssert_assertThat_Test {
     }
 
     @Test
-    fun `should create an assertion instance for suspending lambdas`() =
+    internal fun `should create an assertion instance for suspending lambdas`() =
         runTest {
             val assertion = RaiseAssert.assertThat { aSuspendFunctionWithContext(42) }
             then(assertion).isNotNull.isInstanceOf(RaiseAssert::class.java)

Original file line number	Diff line number	Diff line change
@@ -2,9 +2,11 @@ package `in`.rcard.assertj.arrowcore
`2`	`2`
`3`	`3`	`import arrow.core.raise.Raise`
`4`	`4`	import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailButSucceedsWith
	`5`	+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailWithButSucceedsWith
`5`	`6`	import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailWith.Companion.shouldFailWith
`6`	`7`	import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedButFailed.Companion.shouldSucceedButFailed
`7`	`8`	import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedWith.Companion.shouldSucceedWith
	`9`	+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedWithButFailed.Companion.shouldSucceedWithButFailed
`8`	`10`	`import org.assertj.core.api.AbstractAssert`
`9`	`11`	`import org.assertj.core.internal.ComparisonStrategy`
`10`	`12`	`import org.assertj.core.internal.StandardComparisonStrategy`
`@@ -33,104 +35,104 @@ abstract class AbstractRaiseAssert<`
`33`	`35`	`* Verifies that the function in the [Raise] context succeeds with the given value.`
`34`	`36`	`* @param expectedValue the expected value returned by the function.`
`35`	`37`	`*/`
`36`		`- fun succeedsWith(expectedValue: VALUE) {`
	`38`	`+ fun succeedsWith(expectedValue: VALUE) =`
`37`	`39`	`when (actual) {`
`38`	`40`	`is RaiseResult.Failure<ERROR> -> {`
`39`	`41`	`throwAssertionError(`
`40`		`- shouldSucceedButFailed((actual as RaiseResult.Failure<ERROR>).error),`
	`42`	`+ shouldSucceedWithButFailed(expectedValue, (actual as RaiseResult.Failure<ERROR>).error),`
`41`	`43`	`)`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`is RaiseResult.FailureWithException -> {`
`45`		`- // TODO: Add a specific error message`
	`47`	`+ throw (actual as RaiseResult.FailureWithException).exception`
`46`	`48`	`}`
`47`	`49`
`48`	`50`	`is RaiseResult.Success<VALUE> -> {`
`49`	`51`	`val actualValue = (actual as RaiseResult.Success<VALUE>).value`
`50`	`52`	`if (!comparisonStrategy.areEqual(actualValue, expectedValue)) {`
`51`	`53`	`throwAssertionError(shouldSucceedWith(expectedValue, actualValue))`
	`54`	`+ } else {`
	`55`	`+ // Nothing to do`
`52`	`56`	`}`
`53`	`57`	`}`
`54`	`58`	`}`
`55`		`- }`
`56`	`59`
`57`	`60`	`/**`
`58`	`61`	`* Verifies that the function in the [Raise] context succeeded. No check on the value returned by the function is`
`59`	`62`	`* performed.`
`60`	`63`	`*`
`61`	`64`	`* @see succeedsWith`
`62`	`65`	`*/`
`63`		`- fun succeeds() {`
	`66`	`+ fun succeeds() =`
`64`	`67`	`when (actual) {`
`65`	`68`	`is RaiseResult.Failure<ERROR> ->`
`66`	`69`	`throwAssertionError(`
`67`	`70`	`shouldSucceedButFailed((actual as RaiseResult.Failure<ERROR>).error),`
`68`	`71`	`)`
`69`	`72`
`70`	`73`	`is RaiseResult.FailureWithException -> {`
`71`		`- // TODO: Add a specific error message`
	`74`	`+ throw (actual as RaiseResult.FailureWithException).exception`
`72`	`75`	`}`
`73`	`76`
`74`	`77`	`is RaiseResult.Success<VALUE> -> {`
`75`	`78`	`// Nothing to do`
`76`	`79`	`}`
`77`	`80`	`}`
`78`		`- }`
`79`	`81`
`80`	`82`	`/**`
`81`	`83`	`* Verifies that the function in the [Raise] context fails with the given error.`
`82`	`84`	`* @param expectedError the expected error raised by the function.`
`83`	`85`	`*/`
`84`		`- fun raises(expectedError: ERROR) {`
	`86`	`+ fun raises(expectedError: ERROR) =`
`85`	`87`	`when (actual) {`
`86`	`88`	`is RaiseResult.Failure<ERROR> -> {`
`87`	`89`	`val actualError = (actual as RaiseResult.Failure<ERROR>).error`
`88`	`90`	`if (!comparisonStrategy.areEqual(actualError, expectedError)) {`
`89`	`91`	`throwAssertionError(shouldFailWith(expectedError, actualError))`
	`92`	`+ } else {`
	`93`	`+ // Nothing to do`
`90`	`94`	`}`
`91`	`95`	`}`
`92`	`96`
`93`	`97`	`is RaiseResult.FailureWithException -> {`
`94`		`- // TODO: Add a specific error message`
	`98`	`+ throw (actual as RaiseResult.FailureWithException).exception`
`95`	`99`	`}`
`96`	`100`
`97`	`101`	`is RaiseResult.Success<VALUE> -> {`
`98`	`102`	`throwAssertionError(`
`99`		`- shouldFailButSucceedsWith((actual as RaiseResult.Success<VALUE>).value),`
	`103`	`+ shouldFailWithButSucceedsWith(expectedError, (actual as RaiseResult.Success<VALUE>).value),`
`100`	`104`	`)`
`101`	`105`	`}`
`102`	`106`	`}`
`103`		`- }`
`104`	`107`
`105`	`108`	`/**`
`106`	`109`	`* Verifies that the function in the [Raise] context fails, no matter the type of the logical error.`
`107`	`110`	`*`
`108`	`111`	`* @see raises`
`109`	`112`	`*/`
`110`		`- fun fails() {`
	`113`	`+ fun fails() =`
`111`	`114`	`when (actual) {`
`112`	`115`	`is RaiseResult.Failure<ERROR> -> {`
`113`	`116`	`// Nothing to do`
`114`	`117`	`}`
`115`	`118`
`116`	`119`	`is RaiseResult.FailureWithException -> {`
`117`		`- // TODO: Add a specific error message`
	`120`	`+ throw (actual as RaiseResult.FailureWithException).exception`
`118`	`121`	`}`
`119`	`122`
`120`	`123`	`is RaiseResult.Success ->`
`121`	`124`	`throwAssertionError(`
`122`	`125`	`shouldFailButSucceedsWith((actual as RaiseResult.Success<VALUE>).value),`
`123`	`126`	`)`
`124`	`127`	`}`
`125`		`- }`
`126`	`128`	`}`
`127`	`129`
`128`		`-sealed interface RaiseResult<ERROR : Any, VALUE : Any> {`
`129`		`- data class Success<VALUE : Any>(`
	`130`	`+sealed interface RaiseResult<out ERROR : Any, out VALUE : Any> {`
	`131`	`+ data class Success<out VALUE : Any>(`
`130`	`132`	`val value: VALUE,`
`131`	`133`	`) : RaiseResult<Nothing, VALUE>`
`132`	`134`
`133`		`- data class Failure<ERROR : Any>(`
	`135`	`+ data class Failure<out ERROR : Any>(`
`134`	`136`	`val error: ERROR,`
`135`	`137`	`) : RaiseResult<ERROR, Nothing>`
`136`	`138`
Original file line number	Diff line number	Diff line change
`@@ -10,4 +10,6 @@ internal object Dummy {`
`10`	`10`	`fun Raise<String>.aFunctionThatThrowsAnException(): Int = throw RuntimeException("AN EXCEPTION")`
`11`	`11`
`12`	`12`	`suspend fun Raise<String>.aSuspendFunctionWithContext(input: Int): Int = input`
	`13`	`+`
	`14`	`+ suspend fun Raise<String>.aSuspendFunctionThatThrowsAnException(): Int = throw RuntimeException("AN EXCEPTION")`
`13`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ internal class RaiseAssert_assertThat_Test {`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`@Test`
`17`		- fun `should create an assertion instance for suspending lambdas`() =
	`17`	+ internal fun `should create an assertion instance for suspending lambdas`() =
`18`	`18`	`runTest {`
`19`	`19`	`val assertion = RaiseAssert.assertThat { aSuspendFunctionWithContext(42) }`
`20`	`20`	`then(assertion).isNotNull.isInstanceOf(RaiseAssert::class.java)`