Thank you for this minimal repro bug report!

Adding some tests for this and taking a look at getting this patched.

as an aside if anyone else is seeing this until it gets fixed - it appears the failure is caused by the thread (the blocking call to sleep is not required)

Patch #1206 should fix it!

It turns out the behavior of completion in the presence of multiple threads had a non-deterministic outcome that could, in some cases, cause a random test result.

This patch fixes the issue reported here by making it pass (as expected) while providing a detailed error message and test failure if this race condition is detected.

Is there a workaround for this issue ?

I came with this exception for some Room database tests (androidTest) using the AndroidJUnit4 runner.
It stopped throwing the exception when I added the InstantTaskExecutorRule rule.

@get:Rule
val instantExecutorRule = InstantTaskExecutorRule()

I hope this helps!

Is there a workaround for this issue ?

I'm using something like

@Test
fun test() = runBlocking {
    coroutineJob.join()
}

@objcode I'm not sure if this patch will fix this issue entirely.

E.g. this code, that uses no other threads, fails with the "This job has not completed" message"

    runBlockingTest {
        flow<Unit> {
            suspendCancellableCoroutine<Nothing> {  }
        }.collect {  }
    }

while this code just finishes without any problems:

    runBlockingTest {
        flow<Unit> {
            delay(Long.MAX_VALUE)
        }.collect {  }
    }

@Anton-Spaans-Intrepid I would expect that to fail as it the collect {} will never complete.

In the patched version, you should see a 30 second wait followed by an error.

What behavior are you expecting?

(I just discovered I used my other GitHub account ... ah well 😄)

I expect the test to never end. It will hang.

@streetsofboston Hm, interesting. Can you elaborate on why?

To me this seems like it "should" fail since you're suspending the test coroutine (the coroutine in rbt) with suspendCancellableCoroutine<Nothing> { } which means during cleanup there is a non-completed coroutine.

There's probably three options:

1. Keep this error as is
2. Generate a different error if the only uncompleted job at the end is the test lambda
3. Actually let the test hang forever (this is probably not optimal imo since it's somewhat easy to trigger and hard to debug)

@objcode
If the code were regular non-suspendable code, just plain blocking code, writing this would hang the test forever as well:

fun test() {
    val flowable = Flowable.never<Unit>()
    flowable
        .firstOrError().blockingGet()
}

The above test would never return.

You could make the case that if a non-suspending piece of code never completes, a corresponding suspending piece of code should never resume (and when wrapping that in a runBlockingXXX { ... } block, the code would never return).

Also, a 30 seconds timeout may not be enough for some tests... should the timeout be configurable?

In the end, it is a matter of taste 😄
Hanging tests are not good, but when regular non-suspending code never completes, the test will hang as well. Should that be the same for suspending code inside a runBlockingTest { ... } block or should we use a timeout, keeping in mind that a plain runBlocking { ... } will hang forever?

Any update on when this fix will be released?

Having this issue as well, Seems it only happens if touching files in android framework or that contain livedata not quite sure...

Happens to my tests (not using livedata). Here are the tests: https://github.com/premnirmal/StockTicker/blob/master/app/src/test/kotlin/com/github/premnirmal/ticker/network/StocksApiTest.kt
I have to use runBlocking right now instead of runBlockingTest until this is fixed

Here is another minimal test case:

@Test
fun demo() {
    val scope = TestCoroutineScope()

    scope.runBlockingTest {
        val message = suspendCancellableCoroutine<String> { c ->
            thread(start = true) {
                Thread.sleep(10)
                c.resume("Hello..")
            }
        }

        assertEquals("Hello..", message)
    }
}

This fails with

java.lang.IllegalStateException: This job has not completed yet

at kotlinx.coroutines.JobSupport.getCompletionExceptionOrNull(JobSupport.kt:1188)
at kotlinx.coroutines.test.TestBuildersKt.runBlockingTest(TestBuilders.kt:53)
at kotlinx.coroutines.test.TestBuildersKt.runBlockingTest(TestBuilders.kt:72)

I just ran into this issue.

Any update on a permanent fix for the issue or suggested workarounds would be appreciated.

Saw that workaround after I posted. Thanks!

Having the same issue. But temporarily one can use runBlocking without having any issues

I've run into this issue testing a long running time-line schedule. Using runBlocking is not an option for me as the test would run too long.

Hi guys, I published a post on stackoverlow and just saw your response about this issue. I tried to replace the runBlockingTest by runBlocking but my test seems to wait in an infinite loop.
Can someone help me pass this unit test please?

Same issue with this as of May 12. runBlockingTest throws error with job never completed. runBlocking results in the stuck being stuck in an infinite wait after the mocks are created.

EDIT: Found a way to bypass though by instead of Mocking my Mono/Flux requests. I gave it values instead so my awaitFirstOrNull method would actually return.

Injecting dispatcher worked for me. The main point is to make sure you are using the same test dispatcher instance in the block inside runBlockingTest { }.

For my project, we have DI library to inject dispatchers, and when you override the dispatcher in tests, make sure you are using the same instance instead of creating new instances every time you ask for a dispatcher.

And then when you call runBlockingTest, make sure you call from your test dispatcher instance, e.g. coroutineRule.testDispatcher.runBlockingTest { ... } instead of just runBlockingTest {...}.

I spoke more on this SO thread.

You can get something from this issue

kotlin-hands-on/intro-coroutines#4

runBlockingTest works for me when I switched from using Flow.first to turbine

Still encountered this issue when using Kotlin Coroutines 1.5.1/Micronaut 3.2/Kotest, I created a post on stackoverflow.

This issue is fixed in 1.6.0-RC where runBlockingTest was deprecated (for the sake of backwards compatibility) and runTest without the described pitfall was introduced

I found it hard to find the official docs when searching for runTest, so posting a direct link to help others find the right docs they'll need when migrating away from runBlockingTest.

For me doesn't work this solution. Instead the test falls into eternal processing.

Here is my code:

@Test
fun `when is NULL zone`() = runBlockingTest {
    // Arrange
    accessZone.emit(AccessZone.NULL)

    viewModel = RouteScreenViewModel(
        authorizationFeature = authorizationFeature,
        authenticationFeature = authenticationFeature,
        mainScreenFeature = mainScreenFeature,
        interactor = interactor,
        splashScreenInteractor = splashScreenInteractor
    )

    // Action
    val destination = viewModel.destination.first()

    // Assert
    assertNull(destination)
}

And here is some code of my ViewModel, which i want to test:

init {
    viewModelScope.launch {
        interactor.zone.collect { zone ->
            logger.debug("zone = $zone")
            val nextDestination = when (zone) {
                NULL -> null
                MAIN_CONTENT, MAIN_CONTENT_DEMO -> mainScreenFeature.getRoute()
            }
            nextDestination?.let { destinationFlow.emit(it) }
        }
    }

UPD:
For example when i tried to test MAIN_CONTENT with runBlockingTest in this file, everything it works fine:

@Test
fun `when is MAIN_CONTENT zone`() = runBlockingTest {
    // Arrange
    accessZone.emit(AccessZone.MAIN_CONTENT)
    coEvery { mainScreenFeature.getRoute() } returns "getRoute"

    viewModel = RouteScreenViewModel(
        authorizationFeature = authorizationFeature,
        authenticationFeature = authenticationFeature,
        mainScreenFeature = mainScreenFeature,
        interactor = interactor,
        splashScreenInteractor = splashScreenInteractor
    )

    // Action
    val destination = viewModel.destination.first()

    // Assert
    assertEquals("getRoute", destination)
}

@mnewlive you should migrate to runTest

@mnewlive you should migrate to runTest

Why? If my second test case works fine?
That is, will one test case run with runBlockingTest and the other with runTest?

Because it's deprecated and often time making wrong tests pass.