Testing involving MutableSharedFlow - java.lang.IllegalStateException: This job has not completed yet

Question

Apologies for what is probably a very amateur question. I'm getting to grips with flows and having issues with testing where MutableSharedFlow is concerned.

The following is the simplest example I can construct that recreates the problem:

@ExperimentalCoroutinesApi
@ExperimentalTime
class MyExampleTest {

    val testDispatcher: TestCoroutineDispatcher = TestCoroutineDispatcher()

    @Test
    fun test() = testDispatcher.runBlockingTest  {
        val sharedFlow = MutableSharedFlow<String>()

        sharedFlow.take(2).collect {
            println(it)
        }

        sharedFlow.tryEmit("Hello")
        sharedFlow.tryEmit("World")
    }
}

This results int he following error:

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

    at kotlinx.coroutines.JobSupport.getCompletionExceptionOrNull(JobSupport.kt:1187)
    at kotlinx.coroutines.test.TestBuildersKt.runBlockingTest(TestBuilders.kt:53)
    at kotlinx.coroutines.test.TestBuildersKt.runBlockingTest(TestBuilders.kt:80)
    at com.example.MyExampleTest.test(MyExampleTest.kt:22)

From my limited understanding I think it's something to do with the fact that SharedFlow never completes. But I thought having the take(2) would mitigate this. Any suggestions would be appreciated!

shredder · Accepted Answer · 2021-02-24T18:19:41.500

2

From my limited understanding I think it's something to do with the fact that SharedFlow never completes.

You're right, this is more or less the problem. Flow is based on Coroutines and the coroutine has not completed.

The best way to unit test Flows in my opinion is Turbine:

https://github.com/cashapp/turbine

// Cold Flow
flowOf("one", "two").test {
  assertEquals("one", expectItem())
  assertEquals("two", expectItem())
  expectComplete()
}

// Hot Flow
MutableStateFlow("test").test {
    assertThat(expectItem()).isEqualTo("test")
    cancelAndConsumeRemainingEvents()
}

There is also an open issue about this exact "problem":

https://github.com/Kotlin/kotlinx.coroutines/issues/1204

edited Feb 24 '21 at 18:19

answered Feb 18 '21 at 19:35

shredder

1,438
13
12

This works great with cold flows but still getting similar issues with hot ones :( – SamCosta1 Feb 23 '21 at 11:26
I updated my answer to include a test of a hot flow – shredder Feb 24 '21 at 18:20

score 0 · Answer 2 · answered Nov 19 '21 at 10:32

Inside tests use runBlocking instead of runBlockingTest.

For flow testing combine it with a launch from scope. E.g:

val testDispatcher = TestCoroutineDispatcher()
val testScope = TestCoroutineScope(testDispatcher)

   runBlocking {
        val job1 = testScope.launch {
            doJobThatNeedsCollect(Unit).collect {
                when (it) {
                    is Success -> {
                        isSuccess = true
                        cancel()
                    }
                    is Failure -> {
                        isSuccess = false
                        cancel()
                    }
                }
            }
        }
        while (!job1.isCancelled) {
        }
        assertTrue(isSuccess)
    }

Testing involving MutableSharedFlow - java.lang.IllegalStateException: This job has not completed yet

2 Answers2