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

Merge pull request #949 from robstoll/to-plus-infinitive

Browse Source 
renaming resultAssertions to consistent to + infitinive naming schema
This commit is contained in:
Robert Stoll
2021-07-06 14:53:17 +02:00
committed by GitHub
parent 787d258ae1 d43b37e004
commit ce5d124e70
10 changed files with 230 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
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/resultAssertions.kt
View File

@@ -13,6 +13,7 @@ import ch.tutteli.atrium.logic.kotlin_1_3.isSuccess
*
* @since 0.9.0
*/
@Deprecated("Use toBeASuccess; will be removed with 1.0.0 at the latest", ReplaceWith("this.toBeASuccess<E, T>()"))
fun <E, T : Result<E>> Expect<T>.isSuccess(): Expect<E> =
_logic.isSuccess().transform()
@@ -24,6 +25,10 @@ fun <E, T : Result<E>> Expect<T>.isSuccess(): Expect<E> =
*
* @since 0.9.0
*/
@Deprecated(
"Use toBeASuccess; will be removed with 1.0.0 at the latest",
ReplaceWith("this.toBeASuccess<E, T>(assertionCreator)")
)
fun <E, T : Result<E>> Expect<T>.isSuccess(assertionCreator: Expect<E>.() -> Unit): Expect<T> =
_logic.isSuccess().collectAndAppend(assertionCreator)
@@ -35,6 +40,7 @@ fun <E, T : Result<E>> Expect<T>.isSuccess(assertionCreator: Expect<E>.() -> Uni
*
* @since 0.9.0
*/
@Deprecated("Use toBeAFailure; will be removed with 1.0.0 at the latest", ReplaceWith("this.toBeAFailure<TExpected>()"))
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Expect<TExpected> =
_logic.isFailureOfType(TExpected::class).transform()
@@ -47,6 +53,10 @@ inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Ex
*
* @since 0.9.0
*/
@Deprecated(
"Use toBeAFailure; will be removed with 1.0.0 at the latest",
ReplaceWith("this.toBeAFailure<TExpected>(assertionCreator)")
)
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(
noinline assertionCreator: Expect<TExpected>.() -> Unit
): Expect<TExpected> = _logic.isFailureOfType(TExpected::class).transformAndAppend(assertionCreator)

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)

42
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,20 +4,20 @@ 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.toBeAFailure<IllegalArgumentException>()
private fun isFailure(
private fun toBeAFailure(
expect: Expect<out Result<*>>,
assertionCreator: Expect<IllegalArgumentException>.() -> Unit
) = expect.isFailure<IllegalArgumentException> { assertionCreator() }
) = expect.toBeAFailure<IllegalArgumentException> { assertionCreator() }
@Suppress("unused", "UNUSED_VALUE", "UNUSED_VARIABLE")
private fun ambiguityTest() {
@@ -26,23 +26,23 @@ class ResultExpectationsSpec : ch.tutteli.atrium.specs.integration.ResultExpecta
var star: Expect<Result<*>> = notImplemented()
a1.isSuccess()
a1 = a1.isSuccess { }
a1.toBeASuccess()
a1 = a1.toBeASuccess { }
a1.isFailure<IllegalArgumentException>()
val r1: Expect<IllegalArgumentException> = a1.isFailure<IllegalArgumentException> { }
a1.toBeAFailure<IllegalArgumentException>()
val r1: Expect<IllegalArgumentException> = a1.toBeAFailure<IllegalArgumentException> { }
a1b.isSuccess()
a1b = a1b.isSuccess { }
a1b.toBeASuccess()
a1b = a1b.toBeASuccess { }
a1b.isFailure<IllegalArgumentException>()
val r1b: Expect<IllegalArgumentException> = a1b.isFailure<IllegalArgumentException> { }
a1b.toBeAFailure<IllegalArgumentException>()
val r1b: Expect<IllegalArgumentException> = a1b.toBeAFailure<IllegalArgumentException> { }
star.isSuccess()
star = star.isSuccess { }
star.toBeASuccess()
star = star.toBeASuccess { }
star.isFailure<IllegalArgumentException>()
val r3: Expect<IllegalArgumentException> = star.isFailure<IllegalArgumentException> { }
star.toBeAFailure<IllegalArgumentException>()
val r3: Expect<IllegalArgumentException> = star.toBeAFailure<IllegalArgumentException> { }
}
}
}

10
apis/infix-en_GB/atrium-api-infix-en_GB-common/src/main/kotlin/ch/tutteli/atrium/api/infix/en_GB/helperFunctions.kt
View File

@@ -56,9 +56,18 @@ fun regexPatterns(pattern: String, vararg otherPatterns: String): RegexPatterns
/**
* Helper function to create a [SuccessWithCreator] based on the given [assertionCreator].
*/
@Deprecated("Use aSuccess; will be removed with 1.0.0 at the latest", ReplaceWith("aSuccess<E>(assertionCreator)"))
fun <E> success(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E> =
SuccessWithCreator(assertionCreator)
/**
* Helper function to create a [SuccessWithCreator] based on the given [assertionCreator].
*
* @since 0.17.0
*/
fun <E> aSuccess(assertionCreator: Expect<E>.() -> Unit): SuccessWithCreator<E> =
SuccessWithCreator(assertionCreator)
/**
* Helper function to create a [Value] based on the given [value].
*/
@@ -69,4 +78,3 @@ fun <T> value(value: T): Value<T> = Value(value)
* -- allows to express `T, vararg T`.
*/
fun <T> values(value: T, vararg otherValues: T): Values<T> = Values(value, otherValues)

16
apis/infix-en_GB/atrium-api-infix-en_GB-common/src/main/kotlin/ch/tutteli/atrium/api/infix/en_GB/keywords.kt
View File

@@ -131,13 +131,25 @@ object present : Keyword
object readable : Keyword
/**
* Represents the pseudo keyword `success` as in [toEqual] `success.
* Represents the pseudo keyword `success` as in [toEqual] `success`.
* It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.
*
* @since 0.12.0
*/
@Deprecated(
"Use aSuccess; will be removed with 1.0.0 at the latest",
ReplaceWith("aSuccess", "ch.tutteli.atrium.api.infix.en_GB.aSuccess")
)
object success : Keyword
/**
* A helper construct to allow expressing expectations about a something being a success.
* It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.
*
* @since 0.17.0
*/
object aSuccess : Keyword
/**
* A helper construct to allow expressing expectations about a path being writable.
* It can be used for a parameterless function so that it has one parameter and thus can be used as infix function.
@@ -173,4 +185,4 @@ object duplicates : Keyword
*
* @since 0.17.0
*/
object elements: Keyword
object elements : Keyword

18
apis/infix-en_GB/extensions/kotlin_1_3/atrium-api-infix-en_GB-kotlin_1_3-common/src/main/kotlin/ch/tutteli/atrium/api/infix/en_GB/kotlin_1_3/resultAssertions.kt
View File

@@ -1,7 +1,6 @@
package ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3
import ch.tutteli.atrium.api.infix.en_GB.creating.SuccessWithCreator
import ch.tutteli.atrium.api.infix.en_GB.success
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.logic._logic
import ch.tutteli.atrium.logic.kotlin_1_3.isFailureOfType
@@ -15,14 +14,20 @@ import ch.tutteli.atrium.logic.kotlin_1_3.isSuccess
*
* @since 0.12.0
*/
infix fun <E, T : Result<E>> Expect<T>.toBe(@Suppress("UNUSED_PARAMETER") success: success): Expect<E> =
@Suppress("DEPRECATION")
@Deprecated(
"Use toBe ASuccess; will be removed with 1.0.0 at the latest",
ReplaceWith("this.toBe<E, T>(aSuccess)", "ch.tutteli.atrium.api.infix.en_GB.aSuccess")
)
infix fun <E, T : Result<E>> Expect<T>.toBe(@Suppress("UNUSED_PARAMETER") success: ch.tutteli.atrium.api.infix.en_GB.success): Expect<E> =
_logic.isSuccess().transform()
//TODO move to resultExpectations with 0.18.0
/**
* Expects that the subject of `this` expectation (a [Result]]) is a Success and
* Expects that the subject of `this` expectation (a [Result]) is a success ([Result.isSuccess]) and
* that it holds all assertions the given [SuccessWithCreator.assertionCreator] creates.
*
* Use the function `success { ... }` to create a [SuccessWithCreator].
* Use the function `aSuccess { ... }` to create a [SuccessWithCreator].
*
* @return an [Expect] for the subject of `this` expectation.
*
@@ -39,6 +44,7 @@ infix fun <E, T : Result<E>> Expect<T>.toBe(success: SuccessWithCreator<E>): Exp
*
* @since 0.12.0
*/
@Deprecated("Use toBeAFailure; will be removed with 1.0.0 at the latest", ReplaceWith("this.toBeAFailure<TExpected>()"))
inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Expect<TExpected> =
_logic.isFailureOfType(TExpected::class).transform()
@@ -51,6 +57,10 @@ inline fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(): Ex
*
* @since 0.12.0
*/
@Deprecated(
"Use toBeAFailure; will be removed with 1.0.0 at the latest",
ReplaceWith("this.toBeAFailure<TExpected>(assertionCreator)")
)
inline infix fun <reified TExpected : Throwable> Expect<out Result<*>>.isFailure(
noinline assertionCreator: Expect<TExpected>.() -> Unit
): Expect<TExpected> = _logic.isFailureOfType(TExpected::class).transformAndAppend(assertionCreator)

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

@@ -0,0 +1,42 @@
package ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3
import ch.tutteli.atrium.api.infix.en_GB.aSuccess
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 success.
*
* @since 0.17.0
*/
infix fun <E, T : Result<E>> Expect<T>.toBe(@Suppress("UNUSED_PARAMETER") aSuccess: aSuccess): Expect<E> =
_logic.isSuccess().transform()
/**
* 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 infix fun <reified TExpected : Throwable> Expect<out Result<*>>.toBeAFailure(
noinline assertionCreator: Expect<TExpected>.() -> Unit
): Expect<TExpected> = _logic.isFailureOfType(TExpected::class).transformAndAppend(assertionCreator)

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

@@ -1,5 +1,6 @@
package ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3
import ch.tutteli.atrium.api.infix.en_GB.aSuccess
import ch.tutteli.atrium.api.infix.en_GB.success
import ch.tutteli.atrium.creating.Expect
import ch.tutteli.atrium.specs.integration.ResultExpectationsSpec
@@ -8,34 +9,34 @@ import ch.tutteli.atrium.specs.withFeatureSuffix
import ch.tutteli.atrium.specs.withNullableSuffix
class ResultExpectationsSpec : ResultExpectationsSpec(
("toBe ${success::class::simpleName}" to (Companion::toBeSuccessFeature)).withFeatureSuffix(),
"toBe ${success::class::simpleName}" to Companion::toBeSuccess,
("toBe ${success::class::simpleName}" to (Companion::toBeSuccessFeatureNullable)).withFeatureSuffix()
("toBe ${aSuccess::class::simpleName}" to (Companion::toBeASuccessFeature)).withFeatureSuffix(),
"toBe ${aSuccess::class::simpleName}" to Companion::toBeASuccess,
("toBe ${aSuccess::class::simpleName}" to (Companion::toBeASuccessFeatureNullable)).withFeatureSuffix()
.withNullableSuffix(),
("toBe ${success::class::simpleName}" to (Companion::toBeSuccessNullable)).withNullableSuffix(),
("isFailure" to Companion::isFailureFeature).withFeatureSuffix(),
"isFailure" to Companion::isFailure
("toBe ${aSuccess::class::simpleName}" to (Companion::toBeASuccessNullable)).withNullableSuffix(),
("toBeAFailure" to Companion::toBeAFailureFeature).withFeatureSuffix(),
"toBeAFailure" to Companion::toBeAFailure
) {
companion object {
private fun toBeSuccessFeature(expect: Expect<Result<Int>>) = expect toBe success
private fun isFailureFeature(expect: Expect<Result<Int>>) = expect.isFailure<IllegalArgumentException>()
private fun toBeASuccessFeature(expect: Expect<Result<Int>>) = expect toBe aSuccess
private fun toBeAFailureFeature(expect: Expect<Result<Int>>) = expect.toBeAFailure<IllegalArgumentException>()
private fun toBeSuccessFeatureNullable(expect: Expect<Result<Int?>>) = expect toBe success
private fun toBeASuccessFeatureNullable(expect: Expect<Result<Int?>>) = expect toBe aSuccess
private fun toBeSuccessNullable(
private fun toBeASuccessNullable(
expect: Expect<Result<Int?>>,
assertionCreator: Expect<Int?>.() -> Unit
) = expect toBe success { assertionCreator() }
) = expect toBe aSuccess { assertionCreator() }
private fun toBeSuccess(
private fun toBeASuccess(
expect: Expect<Result<Int>>,
assertionCreator: Expect<Int>.() -> Unit
) = expect toBe success { assertionCreator() }
) = expect toBe aSuccess { assertionCreator() }
private fun isFailure(
private fun toBeAFailure(
expect: Expect<out Result<*>>,
assertionCreator: Expect<IllegalArgumentException>.() -> Unit
) = expect.isFailure<IllegalArgumentException> { assertionCreator() }
) = expect.toBeAFailure<IllegalArgumentException> { assertionCreator() }
@Suppress("unused", "UNUSED_VALUE", "UNUSED_VARIABLE")
private fun ambiguityTest() {
@@ -44,23 +45,23 @@ class ResultExpectationsSpec : ResultExpectationsSpec(
var star: Expect<Result<*>> = notImplemented()
a1 toBe success
a1 = a1 toBe success { }
a1 toBe aSuccess
a1 = a1 toBe aSuccess { }
a1.isFailure<IllegalArgumentException>()
val r1: Expect<IllegalArgumentException> = a1.isFailure<IllegalArgumentException> { }
a1.toBeAFailure<IllegalArgumentException>()
val r1: Expect<IllegalArgumentException> = a1.toBeAFailure<IllegalArgumentException> { }
a1b toBe success
a1b = a1b toBe success { }
a1b toBe aSuccess
a1b = a1b toBe aSuccess { }
a1b.isFailure<IllegalArgumentException>()
val r1b: Expect<IllegalArgumentException> = a1b.isFailure<IllegalArgumentException> { }
a1b.toBeAFailure<IllegalArgumentException>()
val r1b: Expect<IllegalArgumentException> = a1b.toBeAFailure<IllegalArgumentException> { }
star toBe success
star = star toBe success { }
star toBe aSuccess
star = star toBe aSuccess { }
star.isFailure<IllegalArgumentException>()
val r3: Expect<IllegalArgumentException> = star.isFailure<IllegalArgumentException> { }
star.toBeAFailure<IllegalArgumentException>()
val r3: Expect<IllegalArgumentException> = star.toBeAFailure<IllegalArgumentException> { }
}
}
}

4
bundles/infix-en_GB/extensions/atrium-infix-en_GB-smoke-test-kotlin_1_3/src/test/kotlin/custom/SmokeSpec.kt
View File

@@ -6,7 +6,7 @@
package custom
import ch.tutteli.atrium.api.infix.en_GB.kotlin_1_3.toBe
import ch.tutteli.atrium.api.infix.en_GB.success
import ch.tutteli.atrium.api.infix.en_GB.aSuccess
import ch.tutteli.atrium.api.infix.en_GB.toEqual
import ch.tutteli.atrium.api.verbs.expect
import ch.tutteli.atrium.assertions.Assertion
@@ -26,7 +26,7 @@ object SmokeSpec : Spek({
}
test("see if `Result.isSuccess` can be used") {
expect(Result.success(1)) toBe success
expect(Result.success(1)) toBe aSuccess
}
test("see if own expectation function without i18n can be used") {

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")