expectThrows messes up the coroutine dispatcher

[jensbaitingerbosch]

For Unit tests, there is the library org.jetbrains.kotlinx:kotlinx-coroutines-test that provides the function runTest(). It provides a couroutines dispatcher that makes delay() return immediately, so unit tests testing e.g. timeout are still fast.

When expectThrows() is used in such test, it does not 'pass' the coroutine scope. That means that delay() delay for "real" time.

Example (this test fails because the junit timeout fails the test after 100ms, while the delay is only returning after 1sec):

@Test
@Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
fun `delays should return immediately`() = runTest {
 expectThrows<IllegalArgumentException> {
      delay(1000)
      throw IllegalArgumentException()
  }
}

a more 'classical' approach works:

@Test
@Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
fun `delays should return immediately`() = runTest {
 try {
      delay(1000)
      throw IllegalArgumentException()
      fail("this should not be reached, we expect the previous line to throw an exception")
  } catch(e: IllegalArgumentException) {
     // ok
  }
}

Suggestion to fix that issue: All functions like expectThrows() that call code passed as a suspend function should do this using the coroutineScope() function. This would pass the coroutine scheduler.

[Antimonit]

Can confirm. Any Strikt API that accepts suspend lambda will not work as expected when used with dispatchers such as StandardTestDispatcher().

This applies to all expectCatching, expectThrows but also the plain expect.

---

I understand that using suspend lambda inside of these functions might be convenient, but it really should not do runBlocking on the user's behalf.

For example, the following will block the test forever.

@Test
fun `strikt fails`() {
    val dispatcher = StandardTestDispatcher()
    runTest {
        expectThrows<Exception> {
            withContext(dispatcher) {
                error("fail")
            }
        }
    }
}

Converting these two functions:

inline fun <reified E : Throwable> expectThrows(
  noinline action: suspend () -> Any?
): Builder<E> =
  expectCatching(action).failedWith()

fun <T : Any?> expectCatching(action: suspend () -> T): DescribeableBuilder<Result<T>> =
  expectThat(
    runCatching {
      runBlocking { action() }
    }
  )

to suspend:

suspend inline fun <reified E : Throwable> expectThrows(
    noinline action: suspend () -> Any?
): Assertion.Builder<E> =
    expectCatching(action).failedWith()

suspend fun <T : Any?> expectCatching(action: suspend () -> T): DescribeableBuilder<Result<T>> =
    expectThat(
        runCatching {
            action()
        }
    )

indeed fixes the issue and the test succeeds.

---

We can also utilize the fact that inline functions are achromatic in the sense that they don't care whether they are invoked from suspending or non-suspending context. This will work as well:

inline fun <reified E : Throwable> expectThrows(
    action: () -> Any?
): Assertion.Builder<E> =
    expectCatching(action).failedWith()

inline fun <T : Any?> expectCatching(action: () -> T): DescribeableBuilder<Result<T>> =
    expectThat(
        runCatching {
            action()
        }
    )