yeah, that looks like a bug with the implementation of the

task

method

An idea, for tasks again: I check .is success() but as they have the BuildCache enabled they can be .isFromCache() and I don't like the idea of saying .not().isFailure() ,I wanted to do something like: .any( Success, FromCache) but I don't know how to do it

I wonder if

expectCatching { … }.isA<BlahException>

should rethrow the exception if its not the expected exception, or at least show the stacktrace of the unexpected exception

That looks amazing

Hello! I was looking for a way to "group" multiple assertions with a descriptive message, but I did't find an easy (and non-verbose) way to do this in the docs or exploring the API. I implemented something custom, but I wonder if there is a better "native" way. Does anybody know a way to do something like this with the Strikt API?

expectThat(output) {
  should("Replace anonymous id") {
    get { anonymousId() }.isEqualTo("anonymous_user")
    get { context().traits().anonymousId() }.isEqualTo("anonymous_user")
  }
  should("Remove advertisingId and deviceId") {
    get { advertisingId() }.isNull()
    get { deviceId() }.isNull()
  }
}

So I get error messages like these:

✗ Replace anonymous id
    ▼ "5c6b6c02-4dd2d":
      ✗ is equal to "anonymous_user"
              found "5c6b6c02-4dd2d"
    ▼ "5c6b6c02-4dd2d":
      ✗ is equal to "anonymous_user"
              found "5c6b6c02-4dd2d"
  ✗ Remove advertisingId and deviceId
    ▼ "32c85c4d-c39b897c":
      ✗ is null
    ▼ "c55911907ad":
      ✗ is null

Hello! How hard would it be to get Strikt running on Kotlin/JS? As basically only alternative I found for multiplatform that generates such good errors is Atrium - but it's api is ... not that nice There is that one 2 year old issue that says technically it's only a few files that depend on jvm so it shouldn't be that hard I guess? I considered even helping out, but my gradle-fu is too low to convince it to build for multiple platforms...

Just checking out Strikt. My previous preferred library was hamkrest. My first assertion is to validate the count of elements in a list. I see

exactly

,

atMost

, and

atLeast

, but all of these take an additional predicate. Is the preferred approach to do this?

expectThat(it).get { count() }.isEqualTo(3)

Is there any particular reason that there isn't a count matcher directly on list?

Hi. I'm having a strange issue with custom strikt exctensions: I have the following extension that checks for params on a

Intent

for android:

inline fun <reified T : Parcelable> Assertion.Builder<Intent>.hasParams(
  paramsName: String,
  noinline block: Assertion.Builder<T>.() -> Unit = {},
): Assertion.Builder<Intent> {
  return assert("has params %s", expected = paramsName) {
    val params = it.extras?.getParcelable<T>(paramsName)
    if (params != null) {
      expectThat(params).isA<T>().and(block)
    } else {
      fail()
    }
  }
}

When I use this extension, whatever check I put on following lines are marked ass successfull, but those should fail:

@Test
  fun testHasParamsSuccess() {
    val intent = Intent(getApplicationContext(), SelectCountryActivity::class.java)
      .putExtra("param1", TestClass(id = "ABCD"))

    expectThat(intent)
      .hasParams<TestClass>("param1") { get { id }.isEqualTo("ABCD") }
      .assertThat("Simple") { false } // Here assertThat { false } must fail
  }

What I'm doing wrong with the

hasParams

extension?

Lets say I have an

List<Int>

and I want to check that the first value from the list is less than the second. How can I express this in Strikt?

expectThat(listOf(5, 6)) {
  // this[1] is a builder, so can't do this:
  this[0].isLessThan(this[1])
}

Note because of the way the unit test is structured, I don't actually have access to the original list, only the assertion builder. So I can't just do

this[0].isLessThan(originalList[1])

.

lets say i have a list of objects and assert on it. if i know all the field values its easy:

import strikt.api.expectThat
import strikt.assertions.containsExactly

data class Person(val name: String, val age: Int)

expectThat(listOf(Person("james", 28), Person("jimmy", 28))).containsExactly(
    Person("james", 28), Person("jimmy", 28)
)

but what if there is a third field that is random, and that i can’t assert on, what would be the best way to write that in strikt?

data class Person(val name: String, val age: Int, val weight:Double=Random.nextDouble())

i want all the elements and the order but not assert on weight.

please tell me I don’t have to deal with Nexus repos and their awful UI again

Also 0.29.0 is now out which drops

strikt-java-time

in favor of a more general

strikt-jvm

. Some of the JVM-specific stuff from

strikt-core

also moves to the new module.

Hey. looking at the errors, i thouht.... instead of show this:

com.infojobs.app.base.datasource.cachedb.DateConverterTest > should convert Instant objects FAILED
    org.opentest4j.AssertionFailedError: ▼ Expect that 2021-02-24T14:04:22.023Z:
      ✗ is equal to 2021-02-24T14:04:22.023564Z
              found 2021-02-24T14:04:22.023Z

Wouldn't be better to show like this:

com.infojobs.app.base.datasource.cachedb.DateConverterTest > should convert Instant objects FAILED
    org.opentest4j.AssertionFailedError:
    ▼ Expect that 2021-02-24T14:04:22.023Z:
      ✗ is equal to 2021-02-24T14:04:22.023564Z
              found 2021-02-24T14:04:22.023Z

????

I have a function under test that takes an

Iterable<T>

and returns a subset of that given a single element

T

. For example, assume my function has signature

fun <T> Iterable<T>.priorAdjacent(elem: T): List<T>

. Currently use the pattern:

expectThat(elems) { get { priorAdjacent(elems[3]) } isEqualTo elems.slice(1..2) }

which reads nicely and produces understandable failure messages. That being said, is that the best approach?

maybe its time for a new strikt release, the main branch has no transitive dependencies on jcenter.

there are tests that sometimes very rarely fail and it stays a mystery why they do. i wonder if it makes sense to have support for outputting more diagnostic output in that case

Hello, is there any way to use coEvery with Strikt? My intento is to verify if a method is called x times and then do an expectThat for another assertions, and I want to get se see everything that fails

I wonder if it would be cool to add special handling to isEquals failures that have the same string output.

are there matchers for bigdecimal?

what do you think about something like

val parsed=expectThat("""{"abc":"def"}""").isValidJsonFor<MyType>()

I little point I got caught with a few times... using

and { get(SomeClass::someProp).isEqualTo(...) }

on a nullable type without

isNotNull()

allows the

and

, but has

get()

undefined... I wonder if it makes sense to have an

and

in this case in the first place...? What can one do with a nullable type? Also, is there anything like a

isNotNullAnd { ... }

or

withNotNull { }

? I find myself doing

expectThat(result).isNotNull().and { ... }

quite often...

It seems like the

Result

assertions don't all work anymore... they complain that

Result<T>

can't be cast to

T

... maybe the fact that my

T

is nullable is the cause?

Trying to write matchers for https://github.com/michaelbull/kotlin-result, but I'm having a bit of trouble understanding how to return things... I have:

fun <V, E> Assertion.Builder<Result<V, E>>.isFailure(): Assertion.Builder<E> =
    assert("is failure") {
        when {
            it is Err -> pass(
                description = "threw %s",
                actual = it.error
            )
            else -> fail(
                description = "returned %s",
                actual = it.get()
            )
        }
    }
        .get("exception") {
            unwrapError()
        }

fun <V, E> Assertion.Builder<Result<V, E>>.isSuccess(): Assertion.Builder<V> =
    assert("is success") {
        when {
            it is Ok -> pass()
            else -> fail(
                description = "was error ${it.unwrapError()}",
            )
        }
    }
        .get("value") {
            unwrap()
        }

inline fun <reified E> Assertion.Builder<Result<Any?, E>>.failedWith() =
    isFailure().isA<E>()

But when I try `

expectThat(result).isFailure().isA<SomeDomainError>()

I get:

org.opentest4j.AssertionFailedError: ▼ Expect that Ok(SomeStub(id=1,...)):
  ✗ is failure
    returned SomeStub(id=1, ...)

Ok, I got it partially:

inline fun <V, reified E> Assertion.Builder<Result<V, E>>.isFailureOf(): Assertion.Builder<E> =
    assert("is failure of type ${E::class.simpleName}") {
        when {
            it is Err -> pass(
                description = "threw %s",
                actual = it.error
            )
            else -> fail(
                description = "returned %s",
                actual = it.get()
            )
        }
    }
        .get("exception") {
            unwrapError()
        }

But still won't give me the actual

E

I want only the base class of it. Ideally I'd like to provide one type param, and have it report that name in the assert... but it seems like Kotlin won't let me use * for the

V

in

Result

...

Using

first { }

is a bit not fitting for Strikt's usually explicit and nice exceptions:

Mapping 'first matching element %s' failed with: Collection contains no element matching the predicate.

???

This is the issue blocking me on upgrading Strikt to Kotlin 1.5 (I don’t think it will bite you using existing Strikt releases with 1.5 unless you use

Assertion.Builder<Result<*>>

) https://youtrack.jetbrains.com/issue/KT-46890

so what about that strikt release, can i somehow help to get it released?

I'm testing a function with signature

fun <T: Comparable<T>> ClosedRange<T>.intersects(other: ClosedRange<T>): Boolean

. My test has inputs (note there is a fake failure case here,

0..0

is not intersecting):

val intRangeRef = 1..5
val intRangesIntersecting = listOf(0..0, 0..2, 4..5, 4..6)
val intRangesDisjoint = listOf(-2..-1, 6..7)

How would you structure the assertions? So far I've got this, which produces nice output on failures, but thoughts on style?

expectThat(intRangesIntersecting).all {
  get { intRangeRef.intersects(this) } isEqualTo true
  get { this.intersects(intRangeRef) } isEqualTo true
}
expectThat(intRangesDisjoint).all {
  get { intRangeRef.intersects(this) } isEqualTo false
  get { this.intersects(intRangeRef) } isEqualTo false
}

what about making single, get, first, etc available on nullable subjects?