I wonder if there’s a way to prevent

isA

if the generic type of the function has its own generic type

I don't think there is a way to prevent it compile time, but you can always just half-botch it by having the assert always fail when

T::class.typeParameters

is non-empty (eg, the reified class has some generic parameters on it's own)

withCaptured

(mockk) breaks assertion chaining if the slot has not been captured. It throws

Mapping 'captured value %s' failed with: lateinit property captured has not been initialized

. Not sure if this is known or intentional. Would be nice if instead of throwing it would short circuit the block and fail.

comparables have `isGreaterThan`/`isGreaterThanOrEqualTo`/etc assertions but no check if equal using

compareTo

which is useful for things like

BigDecimal

maybe add this?

fun <T : Comparable<T>> Assertion.Builder<T>.compareToEqual(expected: T) =
    assert("is equal using compareTo to %s", expected) {
        if (it.compareTo(expected) == 0) pass() else fail()
    }

Would be nice to have a version of

propertiesAreEqualTo

that doesn’t require

other

to be the same type as the subject. Just a couple minor tweaks.

fun <T : Any> Assertion.Builder<T>.reflectionEquals(
    other: Any,
    ignoredPropertyNames: List<String> = emptyList()
): Assertion.Builder<T> = compose("is equal field-by-field to %s", other) { subject ->
    val otherBeanInfo = Introspector.getBeanInfo(other.javaClass)
    val beanInfo = Introspector.getBeanInfo(subject.javaClass)
    beanInfo.propertyDescriptors
        .filter { it.name != "class" && it.name !in ignoredPropertyNames }
        .forEach { property ->
            val mappedAssertion = get("value of property ${property.name}") {
                property.readMethod(this)
            }
            val otherProperty = otherBeanInfo.propertyDescriptors.firstOrNull { it.name == property.name }
            val otherValue = otherProperty?.let { it.readMethod(other) }
// the rest is the same as propertiesAreEqualTo

It says in the docs:

Block assertions do _not_ fail fast.

but if I use:

expectThat(result) {
  get(Foo::prop1)...
  get(Foo::prop2)...
}

It seems to only print out the first check's result... 🤔

I wonder if

expectThat(...)

was an

inline fun

with reified type param, you could technically pass that type down to the assertions and it could be a great help for things like collections... currently if I pass a

List<Foo>

to

expectThat

I can pass a

List<Baz>

that doesn't inherit from

Foo

to

contains

and that simply doesn't make sense... meaning refactoring to passing another type in the list could easily have the tests pass even though they shouldn't...

Kotlin assertion libraries - JUnit, Hamkrest and Strikt

What about https://github.com/bnorm/kotlin-power-assert

I’ll have to check it out, but I have to edit out enough building time from my videos without a compiler plugin!

Are all the existing tests supposed to pass? I cloned the repo and ran

ArrayAssertions

but am getting strange failures where it's complaining about differing strings that appear to be equal so I wonder if I'm running into some sort of character encoding issue:

▼ Expect that "▼ Expect that ['f', 'n', 'o', 'r', 'd']:
              |  ✗ array content equals ['d', 'i', 's', 'c', 'o', 'r', 'd']":
  ✗ is equal to "▼ Expect that ['f', 'n', 'o', 'r', 'd']:
                |  ✗ array content equals ['d', 'i', 's', 'c', 'o', 'r', 'd']"
          found "▼ Expect that ['f', 'n', 'o', 'r', 'd']:
                |  ✗ array content equals ['d', 'i', 's', 'c', 'o', 'r', 'd']"

The way the tests are written makes it very difficult (and frustrating) to deal with test failures because: 1. Double-clicking on a failed test in IntelliJ doesn't navigate to the failing test 2. Clicking the

Rerun Failed Tests

button makes it seem like they all pass because it doesn't actually rerun any tests I don't have these issues when I use Strikt for testing my own project so I wonder if this is caused by using contexts instead of a separate test method per scenario

Since Kotlin 1.8 no longer supports JVM target 1.6 or 1.7: https://kotlinlang.org/docs/whatsnew18.html#updated-jvm-compilation-target then I think this ticket might no longer apply: https://github.com/robfletcher/strikt/issues/41

Once this PR gets merged: https://github.com/robfletcher/strikt/pull/280 Then I'd like to make another unrelated improvement to that file to speed up CI build times

This should speed up CI builds on future submissions: https://github.com/robfletcher/strikt/pull/281

I finally found the root cause of the test failures. It turns out that they are valid failures that shouldn't pass whenever the

line.separator

system property is anything other than

\n

. This is because raw / triple-quoted strings are hard-coded to always be compiled with

\n

line separators so they can't possibly match output that uses the

line.separator

system property. I didn't find any official documentation about this but found this: https://stackoverflow.com/questions/48933641/kotlin-add-carriage-return-into-multiline-string#:~:text=Kotlin%20multiline%20strings%20are%20always,separator%22))%20. and also found that the Kotlin standard library hardcoded

\n

in the

reindent

function (which is used by the

trimIndent

&

trimMargin

functions that are used throughout the tests): https://github.com/JetBrains/kotlin/blob/master/libraries/stdlib/src/kotlin/text/Indent.kt#:~:text=.joinTo(StringBuild[…]eEstimate)%2C%20%22%5Cn%22) So this brings up 2 issues: 1. The github action to run on windows doesn't seem to represent a regular windows environment. Perhaps something is overwriting the

line.separator

system property. 2. Either the

EOL

value in

DefaultResultWriter

should be set to

\n

(which makes the tests pass) or all the tests that assert against multi-line triple-quoted strings need to be fixed.

Is there any plans for this? I'm always doing this again and again in my test code...

I'm trying to create a couple strikt assertions for this `Result`: https://github.com/michaelbull/kotlin-result I'd like to replace usages like

.isA<Ok<Foo>>().get { value }

with

.isSuccess<Foo>()

but I'm having trouble w/ the generic signatures.

fun <V> Assertion.Builder<Result<V, *>>.isSuccess(): Assertion.Builder<V> = isA<Ok<V>>().get { value }
fun <E> Assertion.Builder<Result<*, E>>.isFailure(): Assertion.Builder<E> = isA<Err<E>>().get { error }

IntelliJ is yelling at me. Any ideas on what these ext funs should look like? Thanks.

propertiesAreEqualToIgnoring

doesn't support nullable attributes as currently written this should work, though

fun <T : Any> Assertion.Builder<T>.propertiesAreEqualToIgnoring(
    other: T,
    vararg ignoredProperties: KProperty1<T, Any?>,
): Assertion.Builder<T> = compareFieldByField(
    other,
    ignoredProperties.map(KProperty1<T, Any?>::name)
)

Just changed

KProperty1<T, Any>

->

KProperty1<T, Any?>

Did anyone try implementing

get()

using Arrow Optics? It might avoid a bunch of gets to drill down a hierarchy and

get { }

that inspects the source code itself...

Hi, new to strikt, I guess there must be a more elegant way to say:

expectThat(result) {
            get { statusCode }.isEqualTo(HttpStatus.OK)
            get { body }.isNotNull().and {
                get { elements }.and {
                    hasSize(1)
                    expectThat(first().subject) {
                        get { coordinates }.isEqualTo(listOf(coord))
                        get { networkType }.isEqualTo(NetworkType.SWITCH)
                    }
                }
            }
        }

i find that i need

single

on a

Map

every once in a while, like there is for

Collection

Might be worth dropping in your std assertions

fun <T : Map<K, V>, K, V> Assertion.Builder<T>.single(): Assertion.Builder<Pair<K, V>> =
    assert("has only one entry") {
        if (it.size == 1) pass(it.size) else fail(it.size)
    }.get("single entry %s") { entries.first().toPair() }

Does Strikt have a matcher for iterables similar to AssertK's

containsOnly

(or Kotest's

shouldContainOnly

)? Description from AssertK: "Asserts the iterable contains only the expected elements, in any order. Duplicate values in the expected and actual are ignored."

Hey there - is there an option to outputting only the assertions that failed rather than the ones that have succeeded as well? Some coworkers have brought up a criticism that for some very long assertions the output is very verbose / noisey so we were thinking that this would be a good middle ground. Maybe even some sort of compacted view or if anyone else from the community has ideas on how to address this.

I find myself wanting

compareToEqual

again. https://kotlinlang.slack.com/archives/CAR7KJ96J/p1663781526609259 This time passing in a comparator:

fun <T : Comparable<T>> Assertion.Builder<T>.compareToEqual(
    expected: T,
    comparator: Comparator<T> = Comparator.naturalOrder(),
) = assert("is equal using Comparator to %s", expected) {
    if (comparator.compare(subject, expected) == 0) pass() else fail()
}

this looks nice: https://github.com/mcmire/super_diff maybe an inspiration for better diffing.

Coming back to strikt after a while... how can you do an or condition? doing some convention checks and want to check if my controller methods have the

@PreAuthorize

annotation or have it as a meta-annotation.

that(methods).all {
                get { annotations.toList() }.any {
                    get { annotationClass }.isEqualTo(PreAuthorize::class)
                    // or...
                    get { annotationClass.annotations }.any { get { annotationClass }.isEqualTo(PreAuthorize::class) }
                }
            }

hi there, I’m wondering about this particular method:

internal fun formatValue(value: Any?): Any =
  when (value) {
    null -> "null"
    is CharSequence -> "\"$value\""
    is Char -> "'$value'"
    is Iterable<*> -> if (value.javaClass.preferToString()) value.toString() else value.map(::formatValue)
    is Byte -> "0x${value.toString(16)}"
    is ByteArray -> "0x${value.toHex()}".truncate()
...

Is there a reason why

if (value.javaClass.preferToString()...

is only in Iterable<*> and not on any class? Reason I’m asking is because I have things like

expectThat(jsonObject1).isEqualTo(jsonObject2)

(from kotlinx.serialization) and it works just fine, but whenever there is a fail, I don’t see beautiful json (like from

jsonObject2.toString()

), but rather a mess with the

=

chars (caused by line 42).

Coming back to Strikt after a bit... How can I do an "or"? Writing some tests to make assertions on JPA entities and want make sure that

val

attributes are annotated with either

@Column(updatable = false)

or

@JoinColumn(updatable = false)

Just testing 1 right now

expectThat(immutableProperties).all {
    get { getAnnotation(Column::class.java) }.isNotNull().get { updatable }.isFalse()
}

Hey, is the lib being updated ? I found this issue in the repository https://github.com/robfletcher/strikt/issues/300

Hi - I saw this announcement of language support for Power Assert in Kotlin 2.0, and wondered where Strikt might be able to make use of it?

After some issues with OSSRH’s switch to token based auth, I’ve finally published v0.35.1