Default Result Assertions Fix (again)

apis/fluent-en_GB/extensions/atrium-api-fluent-en_GB-kotlin_1_3/src/commonTest/kotlin/ch/tutteli/atrium/api/fluent/en_GB/kotlin_1_3/samples/ResultExpectationSamples.kt

@@ -57,7 +57,22 @@ class ResultExpectationSamples {
         }
     }
 
-    //TODO 1.1.0 activate once we have the workaround for #1234 implemented
+
+
+//    @Test
+//    fun toBeAFailureResultFix() {
+//        val message = "wrong argument"
+//        val failure = Result.failure<Int>(IllegalArgumentException(message))
+//
+//
+//
+//        expect(failure) {
+//            toBeAFailure<IllegalArgumentException>()
+//        }
+//
+//
+//    }
+//
 //    @Test
 //    fun toBeAFailureFeature() {
 //        val message = "wrong argument"

logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt

@@ -2,11 +2,14 @@ package ch.tutteli.atrium.logic.kotlin_1_3.impl
 
 import ch.tutteli.atrium.core.ExperimentalNewExpectTypes
 import ch.tutteli.atrium.core.Option
+import ch.tutteli.atrium.core.getOrElse
+import ch.tutteli.atrium.core.polyfills.cast
 import ch.tutteli.atrium.creating.AssertionContainer
 import ch.tutteli.atrium.creating.ExperimentalComponentFactoryContainer
 import ch.tutteli.atrium.creating.FeatureExpect
 import ch.tutteli.atrium.creating.FeatureExpectOptions
 import ch.tutteli.atrium.logic.changeSubject
+import ch.tutteli.atrium.logic.creating.FeatureExpectOptions
 import ch.tutteli.atrium.logic.creating.transformers.FeatureExtractorBuilder
 import ch.tutteli.atrium.logic.creating.transformers.SubjectChangerBuilder
 import ch.tutteli.atrium.logic.creating.transformers.impl.ThrowableThrownFailureHandler
@@ -33,8 +36,42 @@ class DefaultResultAssertions : ResultAssertions {
     override fun <TExpected : Throwable> isFailureOfType(
         container: AssertionContainer<out Result<*>>,
         expectedType: KClass<TExpected>
-    ):  SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected> =
-        container.manualFeature(EXCEPTION) { exceptionOrNull() }.transform().let { previousExpect ->
+    ): SubjectChangerBuilder.ExecutionStep<Throwable?, TExpected> =
+        container.manualFeature(EXCEPTION) {
+
+
+            //fix is here for bug in kotlin 1.3, 1.4, 1.5 (fixed in 1.6) => https://youtrack.jetbrains.com/issue/KT-50974
+            //Comments below explain the fix
+            val badResult = exceptionOrNull()
+            //mapping manually to get internal value throwable - exception or null just produced null + we lost the exception
+            val maybeSubjectResult = container.maybeSubject.map {
+                onSuccess { null }
+                onFailure { it.cause }
+            }
+
+
+            if (maybeSubjectResult.getOrElse { null } != null && badResult == null) {
+                //there is something inside first option type so unwrap
+                val successError = maybeSubjectResult.getOrElse { null }
+
+                if (successError == null) {
+
+                    return@manualFeature exceptionOrNull()
+                }
+                //if the result is a success we have another value to check
+                if (successError.isSuccess) {
+
+                    val valueInsideSuccess = getOrNull() as Result<*>
+                    if (valueInsideSuccess.isFailure) {
+                        return@manualFeature valueInsideSuccess.exceptionOrNull()
+                    }
+                }
+
+            }
+            exceptionOrNull()
+
+
+        }.transform().let { previousExpect ->
             FeatureExpect(
                 previousExpect,
                 FeatureExpectOptions(representationInsteadOfFeature = { it ?: IS_NOT_FAILURE })

misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt

@@ -44,16 +44,16 @@ abstract class ResultExpectationsSpec(
         toBeASuccessNullable.forAssertionCreatorSpec("$toEqualDescr: 2") { toEqual(2) }
     ) {})
 
-    //TODO 1.1.0 activate once we have the workaround for #1234 implemented
-//    include(object : AssertionCreatorSpec<Result<Int>>(
-//        "$describePrefix[failure] ", Result.failure(IllegalArgumentException("oh no...")),
-//        assertionCreatorSpecTriple(
-//            toBeAFailure.name,
-//            "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh no...\"",
-//            { apply { toBeAFailure.invoke(this) { messageToContain("oh no...") } } },
-//            { apply { toBeAFailure.invoke(this) {} } }
-//        )
-//    ) {})
+    //TODO 0.20.0 activate once we have the workaround for #1234 implemented
+    include(object : AssertionCreatorSpec<Result<Int>>(
+        "$describePrefix[failure] ", Result.failure(IllegalArgumentException("oh no...")),
+        assertionCreatorSpecTriple(
+            toBeAFailure.name,
+            "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh no...\"",
+            { apply { toBeAFailure.invoke(this) { messageToContain("oh no...") } } },
+            { apply { toBeAFailure.invoke(this) {} } }
+        )
+    ) {})
 
     fun describeFun(vararg pairs: SpecPair<*>, body: Suite.() -> Unit) =
         describeFunTemplate(describePrefix, pairs.map { it.name }.toTypedArray(), body = body)
@@ -120,22 +120,22 @@ abstract class ResultExpectationsSpec(
                 }
             }
 
-            //TODO 1.1.0 activate once we have the workaround for #1234 implemented
-//            failureFunctions.forEach { (name, toBeAFailureFun, _) ->
-//                it("$name - can perform sub-assertion which holds") {
-//                    expect(resultFailure).toBeAFailureFun { messageToContain("oh no...") }
-//                }
-//                it("$name - can perform sub-assertion which fails, throws AssertionError") {
-//                    expect {
-//                        expect(resultFailure).toBeAFailureFun { messageToContain("oh yes...") }
-//                    }.toThrow<AssertionError> {
-//                        messageToContain(
-//                            "$exceptionDescr: ${IllegalArgumentException::class.fullName}",
-//                            DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\""
-//                        )
-//                    }
-//                }
-//            }
+            //TODO 0.20.0 activate once we have the workaround for #1234 implemented
+            failureFunctions.forEach { (name, toBeAFailureFun, _) ->
+                it("$name - can perform sub-assertion which holds") {
+                    expect(resultFailure).toBeAFailureFun { messageToContain("oh no...") }
+                }
+                it("$name - can perform sub-assertion which fails, throws AssertionError") {
+                    expect {
+                        expect(resultFailure).toBeAFailureFun { messageToContain("oh yes...") }
+                    }.toThrow<AssertionError> {
+                        messageToContain(
+                            "$exceptionDescr: ${IllegalArgumentException::class.fullName}",
+                            DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\""
+                        )
+                    }
+                }
+            }
         }
     }