From c28e1c6e89796c653934cbf23b2f4fd1a09b4c2a Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 28 Jan 2023 19:37:36 +0000 Subject: [PATCH 01/10] if statement --- .../kotlin_1_3/impl/DefaultResultAssertions.kt | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt index c56ae2172a..4a034fb76c 100644 --- a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt +++ b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt @@ -34,7 +34,19 @@ class DefaultResultAssertions : ResultAssertions { container: AssertionContainer>, expectedType: KClass ): SubjectChangerBuilder.ExecutionStep = - container.manualFeature(EXCEPTION) { exceptionOrNull() }.transform().let { previousExpect -> + container.manualFeature(EXCEPTION) { + + + if(exceptionOrNull() == null && container.maybeSubject.map { exceptionOrNull() } != null){ + //unwrap + exceptionOrNull() + } else { + exceptionOrNull() + } + + + + }.transform().let { previousExpect -> FeatureExpect( previousExpect, FeatureExpectOptions(representationInsteadOfFeature = { it ?: IS_NOT_FAILURE }) From 9a8d1a7e6aba8902bf3fd96c17d8c3f0322a9136 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 6 May 2023 21:38:46 +0100 Subject: [PATCH 02/10] Resolve conflicts --- .../impl/DefaultResultAssertions.kt | 33 ++++++++++-- .../integration/ResultExpectationsSpec.kt | 52 +++++++++---------- 2 files changed, 54 insertions(+), 31 deletions(-) diff --git a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt index 4a034fb76c..f05b9df249 100644 --- a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt +++ b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt @@ -2,6 +2,7 @@ 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.creating.AssertionContainer import ch.tutteli.atrium.creating.ExperimentalComponentFactoryContainer import ch.tutteli.atrium.creating.FeatureExpect @@ -36,13 +37,35 @@ class DefaultResultAssertions : ResultAssertions { ): SubjectChangerBuilder.ExecutionStep = 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() + } + } - if(exceptionOrNull() == null && container.maybeSubject.map { exceptionOrNull() } != null){ - //unwrap - exceptionOrNull() - } else { - exceptionOrNull() } + exceptionOrNull() diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt index 6cae39e1af..b39645f6e9 100644 --- a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt +++ b/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>( -// "$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>( + "$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 { -// 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 { + messageToContain( + "$exceptionDescr: ${IllegalArgumentException::class.fullName}", + DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" + ) + } + } + } } } From 002cfb4327d16e7736e26513c4a31f9441644771 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 6 May 2023 16:36:03 +0100 Subject: [PATCH 03/10] Fixes + tests passing --- .../samples/ResultExpectationSamples.kt | 142 +++++----- .../impl/DefaultResultAssertions.kt | 11 +- .../integration/ResultExpectationsSpec.kt | 248 +++++++++--------- 3 files changed, 211 insertions(+), 190 deletions(-) diff --git a/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 b/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 index c54bfb3d62..b689a65eaa 100644 --- a/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 +++ b/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,69 +57,85 @@ class ResultExpectationSamples { } } - //TODO 1.1.0 activate once we have the workaround for #1234 implemented -// @Test -// fun toBeAFailureFeature() { -// val message = "wrong argument" -// val failure = Result.failure(IllegalArgumentException(message)) -// -// expect(failure) -// .toBeAFailure() // subject is now of type IllegalArgumentException -// .messageToContain("argument") -// -// -// fails { // because sub-expectation fails -// expect(failure) -// .toBeAFailure() -// .messageToContain("parameter") // fails -// } -// -// fails { // because wrong Expectation type expected -// expect(failure) -// .toBeAFailure() // fails -// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails -// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated -// } -// -// fails { // because it was a Success -// expect(Result.success(10)) -// .toBeAFailure() // fails -// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails -// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated -// } -// } -// -// @Test -// fun toBeAFailure() { -// val errorMessage = "can not divide by zero" -// val failure = Result.failure(ArithmeticException(errorMessage)) -// -// expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException -// messageToContain("by zero") -// } // subject here is back to type Result -// -// fails { // because sub-expectation fails -// expect(failure).toBeAFailure { -// messageToContain("parameter") // fails -// message.toStartWith("wrong") // still evaluated even though messageToContain already fails -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// -// fails { // because wrong Expectation type expected, but since we use an expectation-group... -// expect(failure).toBeAFailure { -// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// -// fails { // because it was a Success, but since we use a block -// expect(Result.success(10)).toBeAFailure { -// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// } +// TODO 0.20.0 activate once we have the workaround for #1234 implemented + + + @Test + fun toBeAFailureResultFix() { + val message = "wrong argument" + val failure = Result.failure(IllegalArgumentException(message)) + + + + expect(failure) { + toBeAFailure() + } + + + } + + @Test + fun toBeAFailureFeature() { + val message = "wrong argument" + val failure = Result.failure(IllegalArgumentException(message)) + + expect(failure) + .toBeAFailure() // subject is now of type IllegalArgumentException + .messageToContain("argument") + + + fails { // because sub-expectation fails + expect(failure) + .toBeAFailure() + .messageToContain("parameter") // fails + } + + fails { // because wrong Expectation type expected + expect(failure) + .toBeAFailure() // fails + .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails + // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated + } + + fails { // because it was a Success + expect(Result.success(10)) + .toBeAFailure() // fails + .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails + // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated + } + } + + @Test + fun toBeAFailure() { + val errorMessage = "can not divide by zero" + val failure = Result.failure(ArithmeticException(errorMessage)) + + expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException + messageToContain("by zero") + } // subject here is back to type Result + + fails { // because sub-expectation fails + expect(failure).toBeAFailure { + messageToContain("parameter") // fails + message.toStartWith("wrong") // still evaluated even though messageToContain already fails + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + + fails { // because wrong Expectation type expected, but since we use an expectation-group... + expect(failure).toBeAFailure { + messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + + fails { // because it was a Success, but since we use a block + expect(Result.success(10)).toBeAFailure { + messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + } } diff --git a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt index f05b9df249..fbab3ff697 100644 --- a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt +++ b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt @@ -3,11 +3,13 @@ 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 @@ -34,10 +36,11 @@ class DefaultResultAssertions : ResultAssertions { override fun isFailureOfType( container: AssertionContainer>, expectedType: KClass - ): SubjectChangerBuilder.ExecutionStep = + ): SubjectChangerBuilder.ExecutionStep = 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 + + //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 @@ -65,10 +68,12 @@ class DefaultResultAssertions : ResultAssertions { } } - exceptionOrNull() + exceptionOrNull() + + }.transform().let { previousExpect -> FeatureExpect( previousExpect, diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt index b39645f6e9..80cc42306d 100644 --- a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt +++ b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt @@ -44,128 +44,128 @@ abstract class ResultExpectationsSpec( toBeASuccessNullable.forAssertionCreatorSpec("$toEqualDescr: 2") { toEqual(2) } ) {}) - //TODO 0.20.0 activate once we have the workaround for #1234 implemented - include(object : AssertionCreatorSpec>( - "$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) - - val resultSuccess = Result.success(1) - val resultFailure = Result.failure(IllegalArgumentException("oh no...")) - val resultNullSuccess = Result.success(null as Int?) - val resultNullableFailure = Result.failure(IllegalArgumentException("oh no nullable...")) - - val isNotSuccessDescr = DescriptionResultExpectation.IS_NOT_SUCCESS.getDefault() - val isNotFailureDescr = DescriptionResultExpectation.IS_NOT_FAILURE.getDefault() - val exceptionDescr = DescriptionResultExpectation.EXCEPTION.getDefault() - - describeFun(toBeASuccessFeature, toBeASuccess, toBeASuccessFeatureNullable, toBeASuccessNullable, toBeAFailureFeature, toBeAFailure) { - val successFunctions = uncheckedToNonNullable( - unifySignatures(toBeASuccessFeature, toBeASuccess), - unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) - ) - val failureFunctions = unifySignatures(toBeAFailureFeature, toBeAFailure) - - context("subject is $resultSuccess") { - successFunctions.forEach { (name, toBeASuccessFun, _) -> - it("$name - can perform sub-assertion which holds") { - expect(resultSuccess).toBeASuccessFun { toEqual(1) } - } - it("$name - can perform sub-assertion which fails, throws AssertionError") { - expect { - expect(resultSuccess).toBeASuccessFun { toEqual(2) } - }.toThrow { - messageToContain("value: 1", "$toEqualDescr: 2") - } - } - } - - failureFunctions.forEach { (name, toBeAFailureFun, hasExtraHint) -> - it("$name - throws AssertionError showing the expected type" + if (hasExtraHint) " and the expected message" else "") { - expect { - expect(resultSuccess).toBeAFailureFun { messageToContain("oh yes...") } - }.toThrow { - messageToContain( - "exception: $isNotFailureDescr", - "$toBeAnInstanceOfDescr: ${IllegalArgumentException::class.simpleName}" - ) - if (hasExtraHint) { - messageToContain( - DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), - "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" - ) - } - } - } - } - } - - context("subject is $resultFailure") { - successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> - it("$name throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { - expect { - expect(resultFailure).toBeASuccessFun { toEqual(1) } - }.toThrow { - messageToContain("value: $isNotSuccessDescr") - if (hasExtraHint) messageToContain("$toEqualDescr: 1") - } - } - } - - //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 { - messageToContain( - "$exceptionDescr: ${IllegalArgumentException::class.fullName}", - DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" - ) - } - } - } - } - } - - describeFun(toBeASuccessFeatureNullable, toBeASuccessNullable) { - val successFunctions = unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) - - successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> - context("subject is $resultNullSuccess") { - it("$name - can perform sub-assertion which holds") { - expect(resultNullSuccess).toBeASuccessFun { toEqual(null) } - } - it("$name - can perform sub-assertion which fails, throws AssertionError") { - expect { - expect(resultNullSuccess).toBeASuccessFun { toEqual(2) } - }.toThrow { - messageToContain("value: null", "$toEqualDescr: 2") - } - } - } - - context("subject is $resultNullableFailure") { - it("${toBeASuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { - expect { - expect(resultNullableFailure).toBeASuccessFun { toEqual(1) } - }.toThrow { - messageToContain("value: $isNotSuccessDescr") - if (hasExtraHint) messageToContain("$toEqualDescr: 1") - } - } - } - } - } +// //TODO 0.20.0 activate once we have the workaround for #1234 implemented +// include(object : AssertionCreatorSpec>( +// "$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) +// +// val resultSuccess = Result.success(1) +// val resultFailure = Result.failure(IllegalArgumentException("oh no...")) +// val resultNullSuccess = Result.success(null as Int?) +// val resultNullableFailure = Result.failure(IllegalArgumentException("oh no nullable...")) +// +// val isNotSuccessDescr = DescriptionResultExpectation.IS_NOT_SUCCESS.getDefault() +// val isNotFailureDescr = DescriptionResultExpectation.IS_NOT_FAILURE.getDefault() +// val exceptionDescr = DescriptionResultExpectation.EXCEPTION.getDefault() +// +// describeFun(toBeASuccessFeature, toBeASuccess, toBeASuccessFeatureNullable, toBeASuccessNullable, toBeAFailureFeature, toBeAFailure) { +// val successFunctions = uncheckedToNonNullable( +// unifySignatures(toBeASuccessFeature, toBeASuccess), +// unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) +// ) +// val failureFunctions = unifySignatures(toBeAFailureFeature, toBeAFailure) +// +// context("subject is $resultSuccess") { +// successFunctions.forEach { (name, toBeASuccessFun, _) -> +// it("$name - can perform sub-assertion which holds") { +// expect(resultSuccess).toBeASuccessFun { toEqual(1) } +// } +// it("$name - can perform sub-assertion which fails, throws AssertionError") { +// expect { +// expect(resultSuccess).toBeASuccessFun { toEqual(2) } +// }.toThrow { +// messageToContain("value: 1", "$toEqualDescr: 2") +// } +// } +// } +// +// failureFunctions.forEach { (name, toBeAFailureFun, hasExtraHint) -> +// it("$name - throws AssertionError showing the expected type" + if (hasExtraHint) " and the expected message" else "") { +// expect { +// expect(resultSuccess).toBeAFailureFun { messageToContain("oh yes...") } +// }.toThrow { +// messageToContain( +// "exception: $isNotFailureDescr", +// "$toBeAnInstanceOfDescr: ${IllegalArgumentException::class.simpleName}" +// ) +// if (hasExtraHint) { +// messageToContain( +// DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), +// "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" +// ) +// } +// } +// } +// } +// } +// +// context("subject is $resultFailure") { +// successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> +// it("$name throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { +// expect { +// expect(resultFailure).toBeASuccessFun { toEqual(1) } +// }.toThrow { +// messageToContain("value: $isNotSuccessDescr") +// if (hasExtraHint) messageToContain("$toEqualDescr: 1") +// } +// } +// } +// +// //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 { +// messageToContain( +// "$exceptionDescr: ${IllegalArgumentException::class.fullName}", +// DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" +// ) +// } +// } +// } +// } +// } +// +// describeFun(toBeASuccessFeatureNullable, toBeASuccessNullable) { +// val successFunctions = unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) +// +// successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> +// context("subject is $resultNullSuccess") { +// it("$name - can perform sub-assertion which holds") { +// expect(resultNullSuccess).toBeASuccessFun { toEqual(null) } +// } +// it("$name - can perform sub-assertion which fails, throws AssertionError") { +// expect { +// expect(resultNullSuccess).toBeASuccessFun { toEqual(2) } +// }.toThrow { +// messageToContain("value: null", "$toEqualDescr: 2") +// } +// } +// } +// +// context("subject is $resultNullableFailure") { +// it("${toBeASuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { +// expect { +// expect(resultNullableFailure).toBeASuccessFun { toEqual(1) } +// }.toThrow { +// messageToContain("value: $isNotSuccessDescr") +// if (hasExtraHint) messageToContain("$toEqualDescr: 1") +// } +// } +// } +// } +// } }) From e1c6d4d1bc489bcdfb56d63ccf9190e24fb18878 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 6 May 2023 20:56:59 +0100 Subject: [PATCH 04/10] Spacing --- .../atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt | 3 --- 1 file changed, 3 deletions(-) diff --git a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt index fbab3ff697..78ac9ff051 100644 --- a/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt +++ b/logic/extensions/atrium-logic-kotlin_1_3/src/commonMain/kotlin/ch/tutteli/atrium/logic/kotlin_1_3/impl/DefaultResultAssertions.kt @@ -68,9 +68,6 @@ class DefaultResultAssertions : ResultAssertions { } } - - - exceptionOrNull() From 602e32efde1b723817df8a6618b6950a22a3caf1 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 6 May 2023 21:13:54 +0100 Subject: [PATCH 05/10] Comment samples --- .../samples/ResultExpectationSamples.kt | 152 +++++++++--------- 1 file changed, 76 insertions(+), 76 deletions(-) diff --git a/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 b/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 index b689a65eaa..75f3d977d9 100644 --- a/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 +++ b/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 @@ -60,82 +60,82 @@ class ResultExpectationSamples { // TODO 0.20.0 activate once we have the workaround for #1234 implemented - @Test - fun toBeAFailureResultFix() { - val message = "wrong argument" - val failure = Result.failure(IllegalArgumentException(message)) - - - - expect(failure) { - toBeAFailure() - } - - - } - - @Test - fun toBeAFailureFeature() { - val message = "wrong argument" - val failure = Result.failure(IllegalArgumentException(message)) - - expect(failure) - .toBeAFailure() // subject is now of type IllegalArgumentException - .messageToContain("argument") - - - fails { // because sub-expectation fails - expect(failure) - .toBeAFailure() - .messageToContain("parameter") // fails - } - - fails { // because wrong Expectation type expected - expect(failure) - .toBeAFailure() // fails - .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails - // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated - } - - fails { // because it was a Success - expect(Result.success(10)) - .toBeAFailure() // fails - .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails - // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated - } - } - - @Test - fun toBeAFailure() { - val errorMessage = "can not divide by zero" - val failure = Result.failure(ArithmeticException(errorMessage)) - - expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException - messageToContain("by zero") - } // subject here is back to type Result - - fails { // because sub-expectation fails - expect(failure).toBeAFailure { - messageToContain("parameter") // fails - message.toStartWith("wrong") // still evaluated even though messageToContain already fails - // use `.toBeAFailure.` if you want a fail fast behaviour - } - } - - fails { // because wrong Expectation type expected, but since we use an expectation-group... - expect(failure).toBeAFailure { - messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` - // use `.toBeAFailure.` if you want a fail fast behaviour - } - } - - fails { // because it was a Success, but since we use a block - expect(Result.success(10)).toBeAFailure { - messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` - // use `.toBeAFailure.` if you want a fail fast behaviour - } - } - } +// @Test +// fun toBeAFailureResultFix() { +// val message = "wrong argument" +// val failure = Result.failure(IllegalArgumentException(message)) +// +// +// +// expect(failure) { +// toBeAFailure() +// } +// +// +// } +// +// @Test +// fun toBeAFailureFeature() { +// val message = "wrong argument" +// val failure = Result.failure(IllegalArgumentException(message)) +// +// expect(failure) +// .toBeAFailure() // subject is now of type IllegalArgumentException +// .messageToContain("argument") +// +// +// fails { // because sub-expectation fails +// expect(failure) +// .toBeAFailure() +// .messageToContain("parameter") // fails +// } +// +// fails { // because wrong Expectation type expected +// expect(failure) +// .toBeAFailure() // fails +// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails +// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated +// } +// +// fails { // because it was a Success +// expect(Result.success(10)) +// .toBeAFailure() // fails +// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails +// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated +// } +// } +// +// @Test +// fun toBeAFailure() { +// val errorMessage = "can not divide by zero" +// val failure = Result.failure(ArithmeticException(errorMessage)) +// +// expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException +// messageToContain("by zero") +// } // subject here is back to type Result +// +// fails { // because sub-expectation fails +// expect(failure).toBeAFailure { +// messageToContain("parameter") // fails +// message.toStartWith("wrong") // still evaluated even though messageToContain already fails +// // use `.toBeAFailure.` if you want a fail fast behaviour +// } +// } +// +// fails { // because wrong Expectation type expected, but since we use an expectation-group... +// expect(failure).toBeAFailure { +// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` +// // use `.toBeAFailure.` if you want a fail fast behaviour +// } +// } +// +// fails { // because it was a Success, but since we use a block +// expect(Result.success(10)).toBeAFailure { +// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` +// // use `.toBeAFailure.` if you want a fail fast behaviour +// } +// } +// } } From 4b6cec8e3be61184c638435b7729e3b0024c343e Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sat, 6 May 2023 21:42:42 +0100 Subject: [PATCH 06/10] Uncomment spec --- .../integration/ResultExpectationsSpec.kt | 248 +++++++++--------- 1 file changed, 124 insertions(+), 124 deletions(-) diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt index 80cc42306d..b39645f6e9 100644 --- a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt +++ b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt @@ -44,128 +44,128 @@ abstract class ResultExpectationsSpec( toBeASuccessNullable.forAssertionCreatorSpec("$toEqualDescr: 2") { toEqual(2) } ) {}) -// //TODO 0.20.0 activate once we have the workaround for #1234 implemented -// include(object : AssertionCreatorSpec>( -// "$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) -// -// val resultSuccess = Result.success(1) -// val resultFailure = Result.failure(IllegalArgumentException("oh no...")) -// val resultNullSuccess = Result.success(null as Int?) -// val resultNullableFailure = Result.failure(IllegalArgumentException("oh no nullable...")) -// -// val isNotSuccessDescr = DescriptionResultExpectation.IS_NOT_SUCCESS.getDefault() -// val isNotFailureDescr = DescriptionResultExpectation.IS_NOT_FAILURE.getDefault() -// val exceptionDescr = DescriptionResultExpectation.EXCEPTION.getDefault() -// -// describeFun(toBeASuccessFeature, toBeASuccess, toBeASuccessFeatureNullable, toBeASuccessNullable, toBeAFailureFeature, toBeAFailure) { -// val successFunctions = uncheckedToNonNullable( -// unifySignatures(toBeASuccessFeature, toBeASuccess), -// unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) -// ) -// val failureFunctions = unifySignatures(toBeAFailureFeature, toBeAFailure) -// -// context("subject is $resultSuccess") { -// successFunctions.forEach { (name, toBeASuccessFun, _) -> -// it("$name - can perform sub-assertion which holds") { -// expect(resultSuccess).toBeASuccessFun { toEqual(1) } -// } -// it("$name - can perform sub-assertion which fails, throws AssertionError") { -// expect { -// expect(resultSuccess).toBeASuccessFun { toEqual(2) } -// }.toThrow { -// messageToContain("value: 1", "$toEqualDescr: 2") -// } -// } -// } -// -// failureFunctions.forEach { (name, toBeAFailureFun, hasExtraHint) -> -// it("$name - throws AssertionError showing the expected type" + if (hasExtraHint) " and the expected message" else "") { -// expect { -// expect(resultSuccess).toBeAFailureFun { messageToContain("oh yes...") } -// }.toThrow { -// messageToContain( -// "exception: $isNotFailureDescr", -// "$toBeAnInstanceOfDescr: ${IllegalArgumentException::class.simpleName}" -// ) -// if (hasExtraHint) { -// messageToContain( -// DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), -// "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" -// ) -// } -// } -// } -// } -// } -// -// context("subject is $resultFailure") { -// successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> -// it("$name throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { -// expect { -// expect(resultFailure).toBeASuccessFun { toEqual(1) } -// }.toThrow { -// messageToContain("value: $isNotSuccessDescr") -// if (hasExtraHint) messageToContain("$toEqualDescr: 1") -// } -// } -// } -// -// //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 { -// messageToContain( -// "$exceptionDescr: ${IllegalArgumentException::class.fullName}", -// DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" -// ) -// } -// } -// } -// } -// } -// -// describeFun(toBeASuccessFeatureNullable, toBeASuccessNullable) { -// val successFunctions = unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) -// -// successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> -// context("subject is $resultNullSuccess") { -// it("$name - can perform sub-assertion which holds") { -// expect(resultNullSuccess).toBeASuccessFun { toEqual(null) } -// } -// it("$name - can perform sub-assertion which fails, throws AssertionError") { -// expect { -// expect(resultNullSuccess).toBeASuccessFun { toEqual(2) } -// }.toThrow { -// messageToContain("value: null", "$toEqualDescr: 2") -// } -// } -// } -// -// context("subject is $resultNullableFailure") { -// it("${toBeASuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { -// expect { -// expect(resultNullableFailure).toBeASuccessFun { toEqual(1) } -// }.toThrow { -// messageToContain("value: $isNotSuccessDescr") -// if (hasExtraHint) messageToContain("$toEqualDescr: 1") -// } -// } -// } -// } -// } + //TODO 0.20.0 activate once we have the workaround for #1234 implemented + include(object : AssertionCreatorSpec>( + "$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) + + val resultSuccess = Result.success(1) + val resultFailure = Result.failure(IllegalArgumentException("oh no...")) + val resultNullSuccess = Result.success(null as Int?) + val resultNullableFailure = Result.failure(IllegalArgumentException("oh no nullable...")) + + val isNotSuccessDescr = DescriptionResultExpectation.IS_NOT_SUCCESS.getDefault() + val isNotFailureDescr = DescriptionResultExpectation.IS_NOT_FAILURE.getDefault() + val exceptionDescr = DescriptionResultExpectation.EXCEPTION.getDefault() + + describeFun(toBeASuccessFeature, toBeASuccess, toBeASuccessFeatureNullable, toBeASuccessNullable, toBeAFailureFeature, toBeAFailure) { + val successFunctions = uncheckedToNonNullable( + unifySignatures(toBeASuccessFeature, toBeASuccess), + unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) + ) + val failureFunctions = unifySignatures(toBeAFailureFeature, toBeAFailure) + + context("subject is $resultSuccess") { + successFunctions.forEach { (name, toBeASuccessFun, _) -> + it("$name - can perform sub-assertion which holds") { + expect(resultSuccess).toBeASuccessFun { toEqual(1) } + } + it("$name - can perform sub-assertion which fails, throws AssertionError") { + expect { + expect(resultSuccess).toBeASuccessFun { toEqual(2) } + }.toThrow { + messageToContain("value: 1", "$toEqualDescr: 2") + } + } + } + + failureFunctions.forEach { (name, toBeAFailureFun, hasExtraHint) -> + it("$name - throws AssertionError showing the expected type" + if (hasExtraHint) " and the expected message" else "") { + expect { + expect(resultSuccess).toBeAFailureFun { messageToContain("oh yes...") } + }.toThrow { + messageToContain( + "exception: $isNotFailureDescr", + "$toBeAnInstanceOfDescr: ${IllegalArgumentException::class.simpleName}" + ) + if (hasExtraHint) { + messageToContain( + DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), + "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" + ) + } + } + } + } + } + + context("subject is $resultFailure") { + successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> + it("$name throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { + expect { + expect(resultFailure).toBeASuccessFun { toEqual(1) } + }.toThrow { + messageToContain("value: $isNotSuccessDescr") + if (hasExtraHint) messageToContain("$toEqualDescr: 1") + } + } + } + + //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 { + messageToContain( + "$exceptionDescr: ${IllegalArgumentException::class.fullName}", + DescriptionCharSequenceExpectation.TO_CONTAIN.getDefault(), "${DescriptionCharSequenceExpectation.VALUE.getDefault()}: \"oh yes...\"" + ) + } + } + } + } + } + + describeFun(toBeASuccessFeatureNullable, toBeASuccessNullable) { + val successFunctions = unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable) + + successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) -> + context("subject is $resultNullSuccess") { + it("$name - can perform sub-assertion which holds") { + expect(resultNullSuccess).toBeASuccessFun { toEqual(null) } + } + it("$name - can perform sub-assertion which fails, throws AssertionError") { + expect { + expect(resultNullSuccess).toBeASuccessFun { toEqual(2) } + }.toThrow { + messageToContain("value: null", "$toEqualDescr: 2") + } + } + } + + context("subject is $resultNullableFailure") { + it("${toBeASuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) { + expect { + expect(resultNullableFailure).toBeASuccessFun { toEqual(1) } + }.toThrow { + messageToContain("value: $isNotSuccessDescr") + if (hasExtraHint) messageToContain("$toEqualDescr: 1") + } + } + } + } + } }) From a4b4d487d989282b16e686f81761df5ae161158f Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Sun, 7 May 2023 13:56:19 +0100 Subject: [PATCH 07/10] Remove todo --- .../fluent/en_GB/kotlin_1_3/samples/ResultExpectationSamples.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/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 b/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 index 75f3d977d9..9832e857eb 100644 --- a/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 +++ b/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,6 @@ class ResultExpectationSamples { } } -// TODO 0.20.0 activate once we have the workaround for #1234 implemented // @Test From f1d1b3159ee9b618df10b90a55af1c613924a836 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Mon, 8 May 2023 09:58:11 +0100 Subject: [PATCH 08/10] Remove comment out tests --- .../samples/ResultExpectationSamples.kt | 76 ------------------- 1 file changed, 76 deletions(-) diff --git a/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 b/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 index 9832e857eb..8a25972e3f 100644 --- a/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 +++ b/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 @@ -59,82 +59,6 @@ class ResultExpectationSamples { -// @Test -// fun toBeAFailureResultFix() { -// val message = "wrong argument" -// val failure = Result.failure(IllegalArgumentException(message)) -// -// -// -// expect(failure) { -// toBeAFailure() -// } -// -// -// } -// -// @Test -// fun toBeAFailureFeature() { -// val message = "wrong argument" -// val failure = Result.failure(IllegalArgumentException(message)) -// -// expect(failure) -// .toBeAFailure() // subject is now of type IllegalArgumentException -// .messageToContain("argument") -// -// -// fails { // because sub-expectation fails -// expect(failure) -// .toBeAFailure() -// .messageToContain("parameter") // fails -// } -// -// fails { // because wrong Expectation type expected -// expect(failure) -// .toBeAFailure() // fails -// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails -// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated -// } -// -// fails { // because it was a Success -// expect(Result.success(10)) -// .toBeAFailure() // fails -// .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails -// // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated -// } -// } -// -// @Test -// fun toBeAFailure() { -// val errorMessage = "can not divide by zero" -// val failure = Result.failure(ArithmeticException(errorMessage)) -// -// expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException -// messageToContain("by zero") -// } // subject here is back to type Result -// -// fails { // because sub-expectation fails -// expect(failure).toBeAFailure { -// messageToContain("parameter") // fails -// message.toStartWith("wrong") // still evaluated even though messageToContain already fails -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// -// fails { // because wrong Expectation type expected, but since we use an expectation-group... -// expect(failure).toBeAFailure { -// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// -// fails { // because it was a Success, but since we use a block -// expect(Result.success(10)).toBeAFailure { -// messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` -// // use `.toBeAFailure.` if you want a fail fast behaviour -// } -// } -// } } From c8079a60ca1f68eb271f6bb33a736df5e9167f8c Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Mon, 8 May 2023 09:59:38 +0100 Subject: [PATCH 09/10] Amend test deletion --- .../samples/ResultExpectationSamples.kt | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/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 b/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 index 8a25972e3f..4469f92d15 100644 --- a/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 +++ b/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 @@ -59,6 +59,68 @@ class ResultExpectationSamples { + @Test + fun toBeAFailureFeature() { + val message = "wrong argument" + val failure = Result.failure(IllegalArgumentException(message)) + + expect(failure) + .toBeAFailure() // subject is now of type IllegalArgumentException + .messageToContain("argument") + + + fails { // because sub-expectation fails + expect(failure) + .toBeAFailure() + .messageToContain("parameter") // fails + } + + fails { // because wrong Expectation type expected + expect(failure) + .toBeAFailure() // fails + .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails + // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated + } + + fails { // because it was a Success + expect(Result.success(10)) + .toBeAFailure() // fails + .messageToContain("parameter") // not evaluated/reported because toBeAFailure already fails + // use `toBeAFailure<...> { ... }` if you want that all expectations are evaluated + } + } + + @Test + fun toBeAFailure() { + val errorMessage = "can not divide by zero" + val failure = Result.failure(ArithmeticException(errorMessage)) + + expect(failure).toBeAFailure { // subject within this expectation-group is of type ArithmeticException + messageToContain("by zero") + } // subject here is back to type Result + + fails { // because sub-expectation fails + expect(failure).toBeAFailure { + messageToContain("parameter") // fails + message.toStartWith("wrong") // still evaluated even though messageToContain already fails + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + + fails { // because wrong Expectation type expected, but since we use an expectation-group... + expect(failure).toBeAFailure { + messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + + fails { // because it was a Success, but since we use a block + expect(Result.success(10)).toBeAFailure { + messageToContain("parameter") // ...reporting mentions that subject's message was expected `to contain: "parameter"`` + // use `.toBeAFailure.` if you want a fail fast behaviour + } + } + } } From c0f0734e0a5a5221260f28fb7b3d3964710337c5 Mon Sep 17 00:00:00 2001 From: Jordan <46637683+JordanllHarper@users.noreply.github.com> Date: Mon, 8 May 2023 10:00:13 +0100 Subject: [PATCH 10/10] Remove todos --- .../tutteli/atrium/specs/integration/ResultExpectationsSpec.kt | 2 -- 1 file changed, 2 deletions(-) diff --git a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt index b39645f6e9..6f5f5c3669 100644 --- a/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt +++ b/misc/atrium-specs/src/commonMain/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt @@ -44,7 +44,6 @@ abstract class ResultExpectationsSpec( toBeASuccessNullable.forAssertionCreatorSpec("$toEqualDescr: 2") { toEqual(2) } ) {}) - //TODO 0.20.0 activate once we have the workaround for #1234 implemented include(object : AssertionCreatorSpec>( "$describePrefix[failure] ", Result.failure(IllegalArgumentException("oh no...")), assertionCreatorSpecTriple( @@ -120,7 +119,6 @@ abstract class ResultExpectationsSpec( } } - //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...") }