[30] Added the RaiseAssert.fails() assertion

Author: rcardin

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

@@ -2,7 +2,8 @@ package `in`.rcard.assertj.arrowcore
 
 import arrow.core.raise.Raise
 import arrow.core.raise.fold
-import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeded.Companion.shouldFailButSucceeded
+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
@@ -62,7 +63,7 @@ abstract class AbstractRaiseAssert<
      *
      * @see succeedsWith
      */
-    fun succeeded() {
+    fun succeeds() {
         fold(
             block = actual,
             recover = { actualError: ERROR -> throwAssertionError(shouldSucceedButFailed(actualError)) },
@@ -84,7 +85,24 @@ abstract class AbstractRaiseAssert<
             },
             transform = { actualValue ->
                 throwAssertionError(
-                    shouldFailButSucceeded(expectedError, actualValue),
+                    shouldFailWithButSucceedsWith(expectedError, actualValue),
+                )
+            },
+        )
+    }
+
+    /**
+     * Verifies that the function in the [Raise] context fails, no matter the type of the logical error.
+     *
+     * @see raises
+     */
+    fun fails() {
+        fold(
+            block = actual,
+            recover = { _ -> },
+            transform = { actualValue ->
+                throwAssertionError(
+                    shouldFailButSucceedsWith(actualValue),
                 )
             },
         )

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

@@ -0,0 +1,32 @@
+package `in`.rcard.assertj.arrowcore.errors
+
+import org.assertj.core.error.BasicErrorMessageFactory
+
+private const val SHOULD_FAIL_WITH_BUT_SUCCEEDS_WITH_MESSAGE: String =
+    "%nExpecting the lambda to fail with:%n  <%s> %nbut it succeeded with:%n  <%s>"
+
+private const val SHOULD_FAIL_BUT_SUCCEEDS_WITH_MESSAGE: String =
+    "%nExpecting the lambda to fail<%s>, but it succeeded with:%n  <%s>"
+
+/**
+ * Build error message when a lambda should fail with a logic error but it succeeded with a value.
+ *
+ * @author Riccardo Cardin
+ * @since 0.2.0
+ */
+internal class RaiseShouldFailButSucceeds private constructor(
+    expectedError: Any,
+    actualSucceededValue: Any,
+    message: String,
+) : BasicErrorMessageFactory(message, expectedError, actualSucceededValue) {
+    companion object {
+        internal fun shouldFailWithButSucceedsWith(
+            expectedError: Any,
+            actualSucceededValue: Any,
+        ): RaiseShouldFailButSucceeds =
+            RaiseShouldFailButSucceeds(expectedError, actualSucceededValue, SHOULD_FAIL_WITH_BUT_SUCCEEDS_WITH_MESSAGE)
+
+        internal fun shouldFailButSucceedsWith(actualSucceededValue: Any): RaiseShouldFailButSucceeds =
+            RaiseShouldFailButSucceeds("", actualSucceededValue, SHOULD_FAIL_BUT_SUCCEEDS_WITH_MESSAGE)
+    }
+}

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

@@ -0,0 +1,34 @@
+package `in`.rcard.assertj.arrowcore
+
+import `in`.rcard.assertj.arrowcore.RaiseAssert.Companion.assertThat
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailButSucceedsWith
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+@Suppress("ktlint:standard:class-naming")
+internal class RaiseAssert_fails_Test {
+    @Test
+    internal fun `should pass if lambda raises a logical error`() {
+        assertThat { Dummy.aFunctionThatRaisesAnError() }.fails()
+    }
+
+    @Test
+    internal fun `should fail if lambda succeeds with a value instead of failing`() {
+        Assertions
+            .assertThatThrownBy {
+                assertThat { Dummy.aFunctionWithContext(42) }.fails()
+            }.isInstanceOf(AssertionError::class.java)
+            .hasMessage(
+                shouldFailButSucceedsWith(42).create(),
+            )
+    }
+
+    @Test
+    internal fun `should fail if lambda throws an exception`() {
+        Assertions
+            .assertThatThrownBy {
+                assertThat { Dummy.aFunctionThatThrowsAnException() }.fails()
+            }.isInstanceOf(RuntimeException::class.java)
+            .hasMessage("AN EXCEPTION")
+    }
+}

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

@@ -1,41 +1,43 @@
 package `in`.rcard.assertj.arrowcore
 
 import `in`.rcard.assertj.arrowcore.RaiseAssert.Companion.assertThat
-import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeded.Companion.shouldFailButSucceeded
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailButSucceeds.Companion.shouldFailWithButSucceedsWith
 import `in`.rcard.assertj.arrowcore.errors.RaiseShouldFailWith.Companion.shouldFailWith
 import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.Test
 
 internal class RaiseAssert_raises_Test {
-
     @Test
     internal fun `should pass if lambda raises a logical error`() {
         assertThat { Dummy.aFunctionThatRaisesAnError() }.raises("LOGICAL ERROR")
     }
 
     @Test
     internal fun `should fail if lambda raises a logical error different from the expected`() {
-        Assertions.assertThatThrownBy {
-            assertThat { Dummy.aFunctionThatRaisesAnError() }.raises("ANOTHER LOGICAL ERROR")
-        }.isInstanceOf(AssertionError::class.java)
+        Assertions
+            .assertThatThrownBy {
+                assertThat { Dummy.aFunctionThatRaisesAnError() }.raises("ANOTHER LOGICAL ERROR")
+            }.isInstanceOf(AssertionError::class.java)
             .hasMessage(shouldFailWith("ANOTHER LOGICAL ERROR", "LOGICAL ERROR").create())
     }
 
     @Test
     internal fun `should fail if lambda succeeds with a value instead of failing`() {
-        Assertions.assertThatThrownBy {
-            assertThat { Dummy.aFunctionWithContext(42) }.raises("LOGICAL ERROR")
-        }.isInstanceOf(AssertionError::class.java)
+        Assertions
+            .assertThatThrownBy {
+                assertThat { Dummy.aFunctionWithContext(42) }.raises("LOGICAL ERROR")
+            }.isInstanceOf(AssertionError::class.java)
             .hasMessage(
-                shouldFailButSucceeded("LOGICAL ERROR", 42).create(),
+                shouldFailWithButSucceedsWith("LOGICAL ERROR", 42).create(),
             )
     }
 
     @Test
     internal fun `should fail if lambda throws an exception`() {
-        Assertions.assertThatThrownBy {
-            assertThat { Dummy.aFunctionThatThrowsAnException() }.raises("LOGICAL ERROR")
-        }.isInstanceOf(RuntimeException::class.java)
+        Assertions
+            .assertThatThrownBy {
+                assertThat { Dummy.aFunctionThatThrowsAnException() }.raises("LOGICAL ERROR")
+            }.isInstanceOf(RuntimeException::class.java)
             .hasMessage("AN EXCEPTION")
     }
 }

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

@@ -9,14 +9,14 @@ import org.junit.jupiter.api.Test
 internal class RaiseAssert_suceeded_Test {
     @Test
     internal fun `should pass if lambda succeeds`() {
-        assertThat { Dummy.aFunctionWithContext(42) }.succeeded()
+        assertThat { Dummy.aFunctionWithContext(42) }.succeeds()
     }
 
     @Test
     internal fun `should fail if lambda raises an error instead of succeeding`() {
         Assertions
             .assertThatThrownBy {
-                assertThat { Dummy.aFunctionThatRaisesAnError() }.succeeded()
+                assertThat { Dummy.aFunctionThatRaisesAnError() }.succeeds()
             }.isInstanceOf(AssertionError::class.java)
             .hasMessage(
                 shouldSucceedButFailed("LOGICAL ERROR").create(),