Merge pull request #23 from rcardin/raise-dsl-assertions

Added assertions for the `Raise<E>.() -> A` type.

Author: rcardin

README.md

@@ -8,8 +8,9 @@
 
 This project provides a set of [AssertJ](https://assertj.github.io/doc/) assertions for the [Arrow](https://arrow-kt.io/) library. In detail, the project provides assertions for the following Arrow types:
 
-- [x] `Either`
-- [x] `Option`
+- [x] `Either<E, A>`
+- [x] `Option<A>`
+- [x] `Raise<E>.() -> A`
 
 Maybe you're asking yourself: "Why do we need AssertJ assertions for Arrow types?". The answer is simple: We often use Kotlin and Arrow Kt inside a Java project using Spring Boot. In this case, we already have AssertJ in the classpath as an assertion library. So, why not use it to assert Arrow types?
 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>in.rcard</groupId>
     <artifactId>assertj-arrow-core</artifactId>
-    <version>0.1.1-SNAPSHOT</version>
+    <version>0.2.0-SNAPSHOT</version>
 
     <name>AssertJ fluent assertions for Kotlin Arrow Core library</name>
     <description>Rich and fluent assertions for testing Kotlin Arrow Core types</description>
@@ -157,6 +157,11 @@
                         </goals>
                     </execution>
                 </executions>
+                <configuration>
+                    <args>
+                        <arg>-Xcontext-receivers</arg>
+                    </args>
+                </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>

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

@@ -18,6 +18,9 @@ import org.assertj.core.internal.StandardComparisonStrategy
  * @param LEFT type of the left value contained in the [Either].
  * @param RIGHT type of the right value contained in the [Either].
  * @author Riccardo Cardin
+ * @author Simon Frost
+ *
+ * @since 0.0.1
  */
 abstract class AbstractEitherAssert<
     SELF : AbstractEitherAssert<SELF, LEFT, RIGHT>, LEFT : Any, RIGHT : Any,
@@ -88,6 +91,8 @@ abstract class AbstractEitherAssert<
      *
      * @param requirement the consumer that will accept the right-sided value for deep asserting.
      * @return this assertion object.
+     *
+     * @since 0.1.0
      */
     fun hasRightValueSatisfying(requirement: (RIGHT) -> Unit): SELF {
         assertIsRight()
@@ -142,6 +147,7 @@ abstract class AbstractEitherAssert<
      *
      * @param requirement the consumer that will accept the left-sided value for deep asserting.
      * @return this assertion object.
+     * @since 0.1.0
      */
     fun hasLeftValueSatisfying(requirement: (LEFT) -> Unit): SELF {
         assertIsLeft()

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

@@ -15,6 +15,8 @@ import org.assertj.core.internal.StandardComparisonStrategy
  * @param SELF  the "self" type of this assertion class.
  * @param VALUE type of the value contained in the [Option].
  * @author Riccardo Cardin
+ * @author Simon Frost
+ * @since 0.0.1
  */
 abstract class AbstractOptionAssert<
     SELF : AbstractOptionAssert<SELF, VALUE>, VALUE : Any,
@@ -92,6 +94,7 @@ abstract class AbstractOptionAssert<
      *
      * @param requirement to further assert on the object contained inside the [Option].
      * @return this assertion object.
+     * @since 0.1.0
      */
     fun hasValueSatisfying(requirement: (VALUE) -> Unit): SELF {
         assertValueIsPresent()

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

@@ -0,0 +1,63 @@
+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.RaiseShouldFailWith.Companion.shouldFailWith
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedButFailed.Companion.shouldSucceedButFailed
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldSucceedWith.Companion.shouldSucceedWith
+import org.assertj.core.api.AbstractAssert
+import org.assertj.core.internal.ComparisonStrategy
+import org.assertj.core.internal.StandardComparisonStrategy
+
+/**
+ * Assertions for functions within a [Raise] context.
+ *
+ * @param VALUE type of the value returned by the function.
+ * @param ERROR type of the logical error raised by the function.
+ * @author Riccardo Cardin
+ * @since 0.2.0
+ */
+abstract class AbstractRaiseAssert<
+        SELF : AbstractRaiseAssert<SELF, ERROR, VALUE>, ERROR : Any, VALUE : Any,
+        >(lambda: context(Raise<ERROR>) () -> VALUE) :
+    AbstractAssert<SELF, context(Raise<ERROR>) () -> VALUE>(lambda, AbstractRaiseAssert::class.java) {
+
+    private val comparisonStrategy: ComparisonStrategy = StandardComparisonStrategy.instance()
+
+    /**
+     * 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) {
+        fold(
+            block = actual,
+            recover = { actualError: ERROR -> throwAssertionError(shouldSucceedButFailed(expectedValue, actualError)) },
+            transform = { actualValue ->
+                if (!comparisonStrategy.areEqual(actualValue, expectedValue)) {
+                    throwAssertionError(shouldSucceedWith(expectedValue, actualValue))
+                }
+            },
+        )
+    }
+
+    /**
+     * 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) {
+        fold(
+            block = actual,
+            recover = { actualError ->
+                if (!comparisonStrategy.areEqual(actualError, expectedError)) {
+                    throwAssertionError(shouldFailWith(expectedError, actualError))
+                }
+            },
+            transform = { actualValue ->
+                throwAssertionError(
+                    shouldFailButSucceeded(expectedError, actualValue)
+                )
+            },
+        )
+    }
+}

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

@@ -8,6 +8,7 @@ import arrow.core.Either
  * @param LEFT  type of the value on the left contained in the [Either].
  * @param RIGHT type of the value on the right contained in the [Either].
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 class EitherAssert<LEFT : Any, RIGHT : Any>(either: Either<LEFT, RIGHT>?) :
     AbstractEitherAssert<EitherAssert<LEFT, RIGHT>, LEFT, RIGHT>(either) {

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

@@ -7,6 +7,7 @@ import arrow.core.Option
  *
  * @param VALUE type of the value contained in the [Option].
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 class OptionAssert<VALUE : Any>(option: Option<VALUE>?) :
     AbstractOptionAssert<OptionAssert<VALUE>, VALUE>(option) {

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

@@ -0,0 +1,48 @@
+@file:OptIn(ExperimentalTypeInference::class)
+
+package `in`.rcard.assertj.arrowcore
+
+import arrow.core.raise.Raise
+import arrow.core.raise.fold
+import `in`.rcard.assertj.arrowcore.errors.RaiseShouldThrowAnException.Companion.shouldThrowAnException
+import org.assertj.core.api.AbstractThrowableAssert
+import org.assertj.core.api.Assertions
+import org.assertj.core.internal.Failures
+import kotlin.experimental.ExperimentalTypeInference
+
+/**
+ * Assertions for functions within a [Raise] context.
+ *
+ * @param VALUE type of the value returned by the function.
+ * @param ERROR type of the logical error raised by the function.
+ * @author Riccardo Cardin
+ *
+ * @since 0.2.0
+ */
+class RaiseAssert<ERROR : Any, VALUE : Any> private constructor(lambda: Raise<ERROR>.() -> VALUE) :
+    AbstractRaiseAssert<RaiseAssert<ERROR, VALUE>, ERROR, VALUE>(lambda) {
+    companion object {
+        fun <ERROR : Any, VALUE : Any> assertThat(
+            @BuilderInference lambda: Raise<ERROR>.() -> VALUE
+        ): RaiseAssert<ERROR, VALUE> =
+            RaiseAssert(lambda)
+
+        /**
+         * Verifies that the function in the [Raise] context throws an exception.
+         * @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(
+            @BuilderInference shouldRaiseThrowable: Raise<ERROR>.() -> VALUE
+        ): AbstractThrowableAssert<*, out Throwable> {
+            val throwable: Throwable? = fold(block = shouldRaiseThrowable,
+                recover = { null },
+                transform = { null },
+                catch = { exception -> exception })
+
+            @Suppress("KotlinConstantConditions")
+            return throwable?.let { return Assertions.assertThat(throwable) } ?: throw Failures.instance()
+                .failure(Assertions.assertThat(throwable).writableAssertionInfo, shouldThrowAnException())
+        }
+    }
+}

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

@@ -7,6 +7,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * Build error message when an [Either] should be left.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldBeLeft(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be left but was <$actual>.") {

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

@@ -7,6 +7,7 @@ import org.assertj.core.error.BasicErrorMessageFactory
  * Build error message when an [Either] should be right.
  *
  * @author Riccardo Cardin
+ * @since 0.0.1
  */
 internal class EitherShouldBeRight(actual: Either<*, *>) :
     BasicErrorMessageFactory("%nExpecting an Either to be right but was <$actual>.") {