jlengrand/atrium
1
0
Fork 0
mirror of https://github.com/jlengrand/atrium.git synced 2026-03-10 08:01:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename resultAssertion functions to new schema in api-fluent

Browse Source
This commit is contained in:
Robert Stoll
2021-05-26 22:16:09 +02:00
parent 787d258ae1
commit ee9f26a5c6
3 changed files with 98 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
apis/fluent-en_GB/extensions/kotlin_1_3/atrium-api-fluent-en_GB-kotlin_1_3-common/src/main/kotlin/ch/tutteli/atrium/api/fluent/en_GB/kotlin_1_3/resultExpectations.kt Normal file
View File

@@ -0,0 +1,52 @@
package ch.tutteli.atrium.api.fluent.en_GB.kotlin_1_3
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.logic._logic
import ch.tutteli.atrium.logic.kotlin_1_3.isFailureOfType
import ch.tutteli.atrium.logic.kotlin_1_3.isSuccess
/**
* Expects that the subject of `this` expectation (a [Result]) is a success ([Result.isSuccess])
* and returns an [Expect] for the inner type [E].
*
* @return The newly created [Expect] if the given assertion is a success.
*
* @since 0.17.0
*/
fun <E, T : Result<E>> Expect<T>.toBeASuccess(): Expect<E> =
_logic.isSuccess().transform()
/**
* Expects that the subject of `this` expectation (a [Result]) is a success ([Result.isSuccess]) and
* that it holds all assertions the given [assertionCreator] creates.
*
* @return an [Expect] for the subject of `this` expectation.
*
* @since 0.17.0
*/
fun <E, T : Result<E>> Expect<T>.toBeASuccess(assertionCreator: Expect<E>.() -> Unit): Expect<T> =
_logic.isSuccess().collectAndAppend(assertionCreator)
/**
* Expects that the subject of `this` expectation (a [Result]) is a failure ([Result.isFailure]) and
* that it encapsulates an exception of type [TExpected].
*
* @return An [Expect] with the new type [TExpected]
*
* @since 0.17.0
*/
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.toBeAFailure(): Expect<TExpected> =
_logic.isFailureOfType(TExpected::class).transform()
/**
* Expects that the subject of `this` expectation (a [Result]) is a failure ([Result.isFailure]) ,
* that it encapsulates an exception of type [TExpected] and
* that the exception holds all assertions the given [assertionCreator] creates.
*
* @return An [Expect] with the new type [TExpected]
*
* @since 0.17.0
*/
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.toBeAFailure(
noinline assertionCreator: Expect<TExpected>.() -> Unit
): Expect<TExpected> = _logic.isFailureOfType(TExpected::class).transformAndAppend(assertionCreator)

16
apis/fluent-en_GB/extensions/kotlin_1_3/atrium-api-fluent-en_GB-kotlin_1_3-common/src/test/kotlin/ch/tutteli/atrium/api/fluent/en_GB/kotlin_1_3/ResultExpectationsSpec.kt
View File

@@ -4,17 +4,17 @@ import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.*
class ResultExpectationsSpec : ch.tutteli.atrium.specs.integration.ResultExpectationsSpec(
feature0<Result<Int>, Int>(Expect<Result<Int>>::isSuccess),
fun1<Result<Int>, Expect<Int>.() -> Unit>(Expect<Result<Int>>::isSuccess),
feature0<Result<Int?>, Int?>(Expect<Result<Int?>>::isSuccess).withNullableSuffix(),
fun1<Result<Int?>, Expect<Int?>.() -> Unit>(Expect<Result<Int?>>::isSuccess).withNullableSuffix(),
("isFailure" to Companion::isFailureFeature).withFeatureSuffix(),
"isFailure" to Companion::isFailure
feature0<Result<Int>, Int>(Expect<Result<Int>>::toBeASuccess),
fun1<Result<Int>, Expect<Int>.() -> Unit>(Expect<Result<Int>>::toBeASuccess),
feature0<Result<Int?>, Int?>(Expect<Result<Int?>>::toBeASuccess).withNullableSuffix(),
fun1<Result<Int?>, Expect<Int?>.() -> Unit>(Expect<Result<Int?>>::toBeASuccess).withNullableSuffix(),
("isFailure" to Companion::toBeAFailureFeature).withFeatureSuffix(),
"isFailure" to Companion::toBeAFailure
) {
companion object {
private fun isFailureFeature(expect: Expect<Result<Int>>) = expect.isFailure<IllegalArgumentException>()
private fun toBeAFailureFeature(expect: Expect<Result<Int>>) = expect.isFailure<IllegalArgumentException>()
private fun isFailure(
private fun toBeAFailure(
expect: Expect<out Result<*>>,
assertionCreator: Expect<IllegalArgumentException>.() -> Unit
) = expect.isFailure<IllegalArgumentException> { assertionCreator() }

76
misc/specs/atrium-specs-common/src/main/kotlin/ch/tutteli/atrium/specs/integration/ResultExpectationsSpec.kt
View File

@@ -14,44 +14,44 @@ import org.spekframework.spek2.Spek
import org.spekframework.spek2.style.specification.Suite
abstract class ResultExpectationsSpec(
isSuccessFeature: Feature0<Result<Int>, Int>,
isSuccess: Fun1<Result<Int>, Expect<Int>.() -> Unit>,
isSuccessFeatureNullable: Feature0<Result<Int?>, Int?>,
isSuccessNullable: Fun1<Result<Int?>, Expect<Int?>.() -> Unit>,
isFailureFeature: Feature0<Result<Int>, IllegalArgumentException>,
isFailure: Feature1<Result<Int>, Expect<IllegalArgumentException>.() -> Unit, IllegalArgumentException>,
toBeASuccessFeature: Feature0<Result<Int>, Int>,
toBeASuccess: Fun1<Result<Int>, Expect<Int>.() -> Unit>,
toBeASuccessFeatureNullable: Feature0<Result<Int?>, Int?>,
toBeASuccessNullable: Fun1<Result<Int?>, Expect<Int?>.() -> Unit>,
toBeAFailureFeature: Feature0<Result<Int>, IllegalArgumentException>,
toBeAFailure: Feature1<Result<Int>, Expect<IllegalArgumentException>.() -> Unit, IllegalArgumentException>,
describePrefix: String = "[Atrium] "
) : Spek({
include(object : SubjectLessSpec<Result<Int>>(
describePrefix,
isSuccessFeature.forSubjectLess(),
isSuccess.forSubjectLess { toEqual(1) },
isFailureFeature.forSubjectLess(),
isFailure.forSubjectLess { messageToContain("message") }
toBeASuccessFeature.forSubjectLess(),
toBeASuccess.forSubjectLess { toEqual(1) },
toBeAFailureFeature.forSubjectLess(),
toBeAFailure.forSubjectLess { messageToContain("message") }
) {})
include(object : SubjectLessSpec<Result<Int?>>(
"$describePrefix[nullable] ",
isSuccessFeatureNullable.forSubjectLess(),
isSuccessNullable.forSubjectLess { toEqual(1) }
toBeASuccessFeatureNullable.forSubjectLess(),
toBeASuccessNullable.forSubjectLess { toEqual(1) }
) {})
include(object : AssertionCreatorSpec<Result<Int>>(
describePrefix, Result.success(2),
isSuccess.forAssertionCreatorSpec("$toBeDescr: 2") { toEqual(2) }
toBeASuccess.forAssertionCreatorSpec("$toBeDescr: 2") { toEqual(2) }
) {})
include(object : AssertionCreatorSpec<Result<Int?>>(
"$describePrefix[nullable] ", Result.success(2),
isSuccessNullable.forAssertionCreatorSpec("$toBeDescr: 2") { toEqual(2) }
toBeASuccessNullable.forAssertionCreatorSpec("$toBeDescr: 2") { toEqual(2) }
) {})
include(object : AssertionCreatorSpec<Result<Int>>(
"$describePrefix[failure] ", Result.failure(IllegalArgumentException("oh no...")),
assertionCreatorSpecTriple(
isFailure.name,
toBeAFailure.name,
"${VALUE.getDefault()}: \"oh no...\"",
{ apply { isFailure.invoke(this) { messageToContain("oh no...") } } },
{ apply { isFailure.invoke(this) {} } }
{ apply { toBeAFailure.invoke(this) { messageToContain("oh no...") } } },
{ apply { toBeAFailure.invoke(this) {} } }
)
) {})
@@ -67,31 +67,31 @@ abstract class ResultExpectationsSpec(
val isNotFailureDescr = DescriptionResultAssertion.IS_NOT_FAILURE.getDefault()
val exceptionDescr = DescriptionResultAssertion.EXCEPTION.getDefault()
describeFun(isSuccessFeature, isSuccess, isSuccessFeatureNullable, isSuccessNullable, isFailureFeature, isFailure) {
describeFun(toBeASuccessFeature, toBeASuccess, toBeASuccessFeatureNullable, toBeASuccessNullable, toBeAFailureFeature, toBeAFailure) {
val successFunctions = uncheckedToNonNullable(
unifySignatures(isSuccessFeature, isSuccess),
unifySignatures(isSuccessFeatureNullable, isSuccessNullable)
unifySignatures(toBeASuccessFeature, toBeASuccess),
unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable)
)
val failureFunctions = unifySignatures(isFailureFeature, isFailure)
val failureFunctions = unifySignatures(toBeAFailureFeature, toBeAFailure)
context("subject is $resultSuccess") {
successFunctions.forEach { (name, isSuccessFun, _) ->
successFunctions.forEach { (name, toBeASuccessFun, _) ->
it("$name - can perform sub-assertion which holds") {
expect(resultSuccess).isSuccessFun { toEqual(1) }
expect(resultSuccess).toBeASuccessFun { toEqual(1) }
}
it("$name - can perform sub-assertion which fails, throws AssertionError") {
expect {
expect(resultSuccess).isSuccessFun { toEqual(2) }
expect(resultSuccess).toBeASuccessFun { toEqual(2) }
}.toThrow<AssertionError> {
messageToContain("value: 1", "$toBeDescr: 2")
}
}
}
failureFunctions.forEach { (name, isFailureFun, hasExtraHint) ->
failureFunctions.forEach { (name, toBeAFailureFun, hasExtraHint) ->
it("$name - throws AssertionError showing the expected type" + if (hasExtraHint) " and the expected message" else "") {
expect {
expect(resultSuccess).isFailureFun { messageToContain("oh yes...") }
expect(resultSuccess).toBeAFailureFun { messageToContain("oh yes...") }
}.toThrow<AssertionError> {
messageToContain(
"exception: $isNotFailureDescr",
@@ -109,10 +109,10 @@ abstract class ResultExpectationsSpec(
}
context("subject is $resultFailure") {
successFunctions.forEach { (name, isSuccessFun, hasExtraHint) ->
successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) ->
it("$name throws AssertionError" + showsSubAssertionIf(hasExtraHint)) {
expect {
expect(resultFailure).isSuccessFun { toEqual(1) }
expect(resultFailure).toBeASuccessFun { toEqual(1) }
}.toThrow<AssertionError> {
messageToContain("value: $isNotSuccessDescr")
if (hasExtraHint) messageToContain("$toBeDescr: 1")
@@ -120,13 +120,13 @@ abstract class ResultExpectationsSpec(
}
}
failureFunctions.forEach { (name, isFailureFun, _) ->
failureFunctions.forEach { (name, toBeAFailureFun, _) ->
it("$name - can perform sub-assertion which holds") {
expect(resultFailure).isFailureFun { messageToContain("oh no...") }
expect(resultFailure).toBeAFailureFun { messageToContain("oh no...") }
}
it("$name - can perform sub-assertion which fails, throws AssertionError") {
expect {
expect(resultFailure).isFailureFun { messageToContain("oh yes...") }
expect(resultFailure).toBeAFailureFun { messageToContain("oh yes...") }
}.toThrow<AssertionError> {
messageToContain(
"$exceptionDescr: ${IllegalArgumentException::class.fullName}",
@@ -138,17 +138,17 @@ abstract class ResultExpectationsSpec(
}
}
describeFun(isSuccessFeatureNullable, isSuccessNullable) {
val successFunctions = unifySignatures(isSuccessFeatureNullable, isSuccessNullable)
describeFun(toBeASuccessFeatureNullable, toBeASuccessNullable) {
val successFunctions = unifySignatures(toBeASuccessFeatureNullable, toBeASuccessNullable)
successFunctions.forEach { (name, isSuccessFun, hasExtraHint) ->
successFunctions.forEach { (name, toBeASuccessFun, hasExtraHint) ->
context("subject is $resultNullSuccess") {
it("$name - can perform sub-assertion which holds") {
expect(resultNullSuccess).isSuccessFun { toEqual(null) }
expect(resultNullSuccess).toBeASuccessFun { toEqual(null) }
}
it("$name - can perform sub-assertion which fails, throws AssertionError") {
expect {
expect(resultNullSuccess).isSuccessFun { toEqual(2) }
expect(resultNullSuccess).toBeASuccessFun { toEqual(2) }
}.toThrow<AssertionError> {
messageToContain("value: null", "$toBeDescr: 2")
}
@@ -156,9 +156,9 @@ abstract class ResultExpectationsSpec(
}
context("subject is $resultNullableFailure") {
it("${isSuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) {
it("${toBeASuccessFeature.name} throws AssertionError" + showsSubAssertionIf(hasExtraHint)) {
expect {
expect(resultNullableFailure).isSuccessFun { toEqual(1) }
expect(resultNullableFailure).toBeASuccessFun { toEqual(1) }
}.toThrow<AssertionError> {
messageToContain("value: $isNotSuccessDescr")
if (hasExtraHint) messageToContain("$toBeDescr: 1")