Support assertThrows() with suspending functions in Kotlin

[DerkSchooltink]

Often when I write a unit test that has to assert that a certain exception is thrown I use the assertThrows() method. But I find myself regularly having to test suspending functions, so I have to wrap my function with a runBlocking(). This is a lot of repeating code if your entire codebase is heavily based on coroutines.

Proposed fix

I couldn't possibly have made this issue without also thinking about a solution.

Effectively, this is what I came up with:

private inline fun <reified T : Throwable> assertThrows(
        noinline executable: suspend () -> Unit
    ) = assertThrows(T::class.java) {
        runBlocking {
            executable()
        }
    }

This way you can pass suspending functions as parameter executable, which will be invoked in a runBlocking() to make sure the suspending function joins before continuing.

tl;dr

I think it would be a good addition to JUnit Jupiter to have functions that allow easy testing of suspending functions.

[marcphilipp]

Thanks for creating the issue! While I'm not familiar with Kotlin's coroutines and suspending functions, but I can see how that would make sense.

@DerkSchooltink Would you be interested in submitting a PR?

[DerkSchooltink]

I have created a PR with my suggested fix, but I'm having some issues with Azure pipeline not compiling coroutines library from Kotlin too well. I'm seeing actual bytecode in the stacktrace. Might be an issue on my end, will investigate later.

#1853

[mkobit]

Probably related to https://youtrack.jetbrains.com/issue/KT-22228

[marcphilipp]

Reopening due to #2042 (comment)

[marcphilipp]

Resolves in master in c5d658c.

[binkley]

@DerkSchooltink

Sorry to comment on a long-closed issue. I tried the "simplest thing". If the unit test function is not itself suspending, how does it test a suspending function?

internal class ScratchTest {
    @Test
    fun `should test suspending functions`() {
        assertThrows<IllegalStateException> { failing() }
    }
}

private suspend fun failing() {
    delay(1L) // pretend
    error("Fail on purpose")
}

The compiler rightfully complains that "failing()" cannot be called from "assertThrows" as there is no suspension context. What is the scope and context for test functions? (https://kotlinlang.org/docs/reference/coroutines/basics.html)

The merged commit did not include tests I could examine as examples.

[ashdavies]

Hi @binkley, the design of assertThrows is to allow you to build your own CoroutineContext as to not interfere with your test setup, as such I would recommend using the Kotlin Coroutines Test dependency (https://github.com/Kotlin/kotlinx.coroutines/tree/master/kotlinx-coroutines-test#testing-regular-suspend-functions) to run suspended functions under test.

    @Test
    fun `should test suspending functions`() = runBlockingTest {
        assertThrows<IllegalStateException> { failing() }
    }

[williamboman-pp]

Hey! This does not seem to work with the assertDoesNotThrow function, only wtih assertThrows

[sbrannen]

@williamboman-pp, this issue was closed over a year ago.

Please open a new issue to address assertDoesNotThrow.

Thanks

[CyxouD]

@ashdavies Doesn't work with Kotlin 1.8.0, JUnit 4.13.2 and kotlinx-coroutines-test 1.5.2 (see screenshot). Maybe there should be assertFailsWith function. Furthermore, runBlockingTest is deprecated

For now, I use approach with runBlocking as @DerkSchooltink suggested:

 assertThrows(Error::class.java) {
            runBlocking {
                coroutineFunction()
            }
        }

Another solution is runCatching {}.onFailure { assertThat(..., isInstanceOf(Error::class.java) } as suggested here https://stackoverflow.com/a/63867289/7867180