Add conditional invert function with parameter to conditionally invert

[dalewking]

Sometimes you need to conditionally invert a matcher based on some data, so depending on the data you might need to invert the matcher or you may not. It occurs to me (and am writing an extension function to do it myself) that it would be hander if there was a member or extension function that did this:

fun <T> Matcher<T>.invertIf(invert: Boolean): Matcher<T> = if(invert) invert() else this

[sksamuel]

Do you have an example of the usage?

…

On Fri, 19 Nov 2021, 20:44 Dale King, ***@***.***> wrote: Sometimes you need to conditionally invert a matcher based on some data, so depending on the data you might need to invert the matcher or you may not. It occurs to me (and am writing an extension function to do it myself) that it would be hander if the invert function on Matcher were written like this: fun invert(inverted: Boolean = true): Matcher<T> = if(inverted) Matcher { with(test(it)) { MatcherResult(!passed(), { negatedFailureMessage() }, { failureMessage() }) } } } else this } — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#2658>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAFVSGUMGYDUP5HVIZTRJKDUM4DRDANCNFSM5INNWSFA> . Triage notifications on the go with GitHub Mobile for iOS <https://apps.apple.com/app/apple-store/id1477376905?ct=notification-email&mt=8&pt=524675> or Android <https://play.google.com/store/apps/details?id=com.github.android&referrer=utm_campaign%3Dnotification-email%26utm_medium%3Demail%26utm_source%3Dgithub>.

[dalewking]

In my case I am using reflection to verify the characteristics of some properties on a data class are defined correctly. This is a boiled down version of my code. Say you have this data class:

data class Property(
    val property: KProperty0<*>,
    val expectedName: String,
    val shouldBeNullable: Boolean = false,
    val shouldBeMutable: Boolean = false,
)

I might use it like this:

class MyTests : FunSpec({
  context("Properties should be defined correctly") {
    withData(
      Property(MyClass::foo, "foo"),
      Property(MyClass::mutableProperty, "mutableProperty", mutable = true),
      Property(MyClass::nullableProperty, "nullableProperty", nullable = true),
    ) { (property, name, nullable, mutable) ->
      property.asClue {
          it shouldBeNamed name
          it should beNotNullable.invertIf(nullable)
          it should beImmutable.invertIf(mutable)
    }
  }
})

which is using some reflective matchers I created on KProperty (let me know if you would like them to add to the library)

[sksamuel]

Makes sense to add these I think.

[dalewking]

I fixed the definition in the first comment that swallowed the generic parameters.

And if you are interested these are the reflective property matchers I mentioned:

fun beNullable() = Matcher<KProperty<*>> {
    MatcherResult(
        it.returnType.isMarkedNullable,
        "Property $it return type should be nullable",
        "Property $it return type should not be nullable",
    )
}

fun beNotNullable() = beNullable().invert()

fun beMutable() = Matcher<KProperty<*>> {
    MatcherResult(
        it is KMutableProperty<*>,
        "Property $it return type should be mutable",
        "Property $it return type should be immutable",
    )
}

fun beImmutable() = beMutable().invert()

fun beNamed(expectedName: String) = Matcher<KProperty<*>> {
    MatcherResult(
        it.name == expectedName,
        "Property $it should be named $expectedName",
        "Property $it should not be named $expectedName",
    )
}

fun KProperty<*>.shouldBeNullable() = this should beNullable()
fun KProperty<*>.shouldBeNotNullable() = this should beNullable().invert()
fun KProperty<*>.shouldBeMutable() = this should beMutable()
fun KProperty<*>.shouldBeImmutable() = this should beImmutable()
infix fun KProperty<*>.shouldBeNamed(expectedName: String) = this should beNamed(expectedName)

fun <T, V> T.shouldHave(property: KProperty1<T, V>, matcher: Matcher<V>): T =
    this.apply {
        withClue("Property $property") {
            property.get(this) shouldHave matcher
        }
    }

fun <T, V> T.shouldHave(property: KProperty1<T, V>, it: V): T =
    this.apply {
        withClue("Property $property") {
            property.get(this) shouldBe it
        }
    }

[sksamuel]

Will be included in 5.1.0