Getting kotlin error "After waiting for 60000 ms, the test coroutine is not completing"

Question

I'm new at testing, trying to take second flow value and assert it, When i run this test one by one runs fine but when i run whole test once first test runs fine and rest of test give me timeout error.

Error :

After waiting for 60000 ms, the test coroutine is not completing
kotlinx.coroutines.test.UncompletedCoroutinesError: After waiting for 60000 ms, the test coroutine is not completing
    at app//kotlinx.coroutines.test.TestBuildersKt__TestBuildersKt$runTestCoroutine$3$3.invokeSuspend(TestBuilders.kt:304)
    (Coroutine boundary)

@OptIn(ExperimentalCoroutinesApi::class)
class HomeViewModelTest {

    private lateinit var viewModel: HomeViewModel
    private val testDispatcher = UnconfinedTestDispatcher()

    @Before
    fun setup() {
        viewModel = HomeViewModel(FakeOrderRepository())
        Dispatchers.setMain(testDispatcher)
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
        testDispatcher.cancel()
    }

    @Test
    fun flowViewModelTesting1() = runTest {
        val result = viewModel.homeUiState.drop(1).first()
        assertThat(true).isTrue()
    }


    @Test
    fun flowViewModelTesting2() = runTest {
        val result = viewModel.homeUiState.drop(1).first()
        assertThat(true).isTrue()
    }
}

How do you update the value of `homeUiState`? Are you sure it is updated? — broot, Jun 05 '22 at 11:31
It looks like `homeUiState` is always updated only once per test session, so only the first test finishes. Do you share some state/objects between instances of `HomeViewModel` that might cause `homeUiState` to be updated only once, even when multiple `HomeViewModel` instances are created? — broot, Jun 05 '22 at 12:07

score 7 · Answer 1 · edited Aug 07 '22 at 18:24

7

I had the same issue. Replacing UnconfinedTestDispatcher() with StandardTestDispatcher() will solve the problem.

edited Aug 07 '22 at 18:24

Jeremy Caney

7,102
69
48
77

answered Aug 06 '22 at 19:37

Ying Ye

71
1
3

score 1 · Answer 2 · answered Aug 03 '22 at 02:22

1

Most of the time reason for this error is that you have not finish your observer variable call.

At the end of your test case call finish() method on your observer variable.

observerVariable.finish()

answered Aug 03 '22 at 02:22

Rajneesh Shukla

1,048
13
21

What is the type of `observerVariable` in this case? – Rod Mar 01 '23 at 19:41
1

This is the hot variable which you are observing. for example Flow. – Rajneesh Shukla Mar 12 '23 at 08:20

score 1 · Answer 3 · answered Feb 28 '23 at 10:27

@RunWith(AndroidJUnit4::class)
class Test {

    private val dispatcher = TestCoroutineDispatcher()
    private val testScope = TestCoroutineScope(dispatcher)
    
    @Before
    fun setUp() {
        Dispatchers.setMain(dispatcher)
    }
    @After
    fun tearDown() {
        Dispatchers.resetMain()
        dispatcher.cleanupTestCoroutines()
        unmockkAll()
    }
    
    @OptIn(ExperimentalCoroutinesApi::class)
    @Test
    fun test() = runTest {
        testScope.launch {
                 // call your suspend method here
                Utils.testSuspendMethod()
            )
          //add here assertions for the method
        }

    }

}

score 0 · Answer 4 · answered Nov 01 '22 at 20:55

0

You're not using the testDispatcher. You should pass it to runTest like:

runTest(UnconfinedTestDispatcher()) {}

https://developer.android.com/kotlin/coroutines/test

answered Nov 01 '22 at 20:55

Chris Overcash

1

Allan Veloso · Answer 5 · 2023-03-10T19:02:43.533

This is maybe because there is a coroutine that never ends in your view model or in his dependencies (like the repository). There is a couple of things you can try:

I am not sure if coroutines debugger is available on Android Studio right now, but if it is you can put a breakpoint after all your test functions and use it to check which coroutine is still running.
Check in your view model and its dependencies if you are using an external scope like CoroutineScope(SupervisorJob() + Dispatchers.Default). If you are, make sure you are using with a suspend function that finishes in 60s. If you are using to observe a value like in myFlow.onEach{}.launchIn(externalScope) it may be that because the job is still running.
Don't replace the dispatchers of your external scope with the test scope (like in CoroutineScope(SupervisorJob() + myTestDispatcher)), otherwise the test execution will block the execution of your suspend functions and the suspend function will only return after your test is over, which may cause this infinite testing behavior or a screen being stucked if you are making instrumented tests. Also, put your scopes and dispatchers on the constructor, so in tests you can control which one is being used.

    @Test
    fun flowViewModelTesting1() = runTest {

        /** Given **/
        val viewModel = HomeViewModel(
            orderRepository = FakeOrderRepository(
                // ioDispatcher may execute execute the task of call the server
                // or in the fake version wait 1,000 ms and return a mock
                ioDispatcher =  TestDispatcher(this.testScheduler),
                // External scope may launch a order update
                externalScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
            )
        )

        /** When **/
        val result = viewModel.homeUiState.drop(1).first()

        /** Then **/
        assertEquals(
            expected = true,
            actual = result.myBoolean
        )
    }

score -1 · Answer 6 · answered Feb 13 '23 at 06:13

All of these answers are wrong, you are looking for dispatchTimeoutMs:

@Test
fun `my long-running test`() = runTest(
  dispatchTimeoutMs = 60000L, // Increase this number as needed, this is the default which is 60 seconds in milliseconds
  context = testDispatcher // also, still pass in a TestDispatcher
) {
  // ... Rest of your long-running test
}

Normally, you should try to make your test run faster, or test smaller things, but I have needed to do this from time-to-time.

score -2 · Answer 7 · answered Mar 10 '23 at 17:53

Actually, the way I handled it:

I was trying to read state from my viewModel, and I realized that I needed to cancel the job reading the state:

@Test
fun `test click gets right function call if token timed out`() =
    runTest(StandardTestDispatcher()) {
        var viewState: ChangeBranchViewState
        coEvery { changeBranchAppointmentsUseCase.invoke(any()) } returns
                GetAppointmentDataResult.TokenExpired()
        viewModel.viewState.update { it.copy(branchNumberInput = "1234") }
        viewModel.onSubmit()
        assertFalse(viewModel.navigateToSettings.value)

        val job = launch {
            viewModel.viewState.collect {
                viewState = it
                assertTrue(viewState.tokenTimedOutGoToLogin)
            }
        }
        job.cancel()
    }

this will cancel job without testing anything inside – Antonis Radz Apr 11 '23 at 09:08 — Antonis Radz, Apr 11 '23 at 09:08

score -3 · Answer 8 · answered Jul 13 '22 at 15:28

When you use runTest, so you're using StandardTestDispatcher by default that means it won't immediately run. You have to launch your test from the same dispatcher that you have been using for a ViewModel

Replace

runTest {

with

testDispather.runTest {

it should work, give it a try. I can't share much without checking your viewmodel code.

Getting kotlin error "After waiting for 60000 ms, the test coroutine is not completing"

8 Answers8

Linked