runBlockingTest just skips the delays in your case but not override the dispatcher used in the ViewModel with your test dispatcher. You need to inject TestCoroutineDispatcher to your ViewModel or since you are using viewModelScope.launch {} which already uses Dispatchers.Main by default, you need to override the main dispatcher via Dispatchers.setMain(testCoroutineDispatcher). You can create and add the following rule to your test file.

class MainCoroutineRule(
        val testDispatcher: TestCoroutineDispatcher = TestCoroutineDispatcher()
) : TestWatcher() {

    override fun starting(description: Description?) {
        super.starting(description)
        Dispatchers.setMain(testDispatcher)
    }

    override fun finished(description: Description?) {
        super.finished(description)
        Dispatchers.resetMain()
        testDispatcher.cleanupTestCoroutines()
    }
} 

And in your test file

@get:Rule
var mainCoroutineRule = MainCoroutineRule()

@Test
fun `observe user wallets ok`() = mainCoroutineRule.testDispatcher.runBlockingTest {
}

Btw it is always a good practice to inject dispatchers. For instance if you would have been using a dispatcher other than Dispatchers.Main in your coroutine scope like viewModelScope.launch(Dispatchers.Default), then your test will fail again even if you are using a test dispatcher. The reason is you can only override main dispatcher with Dispatchers.setMain() as it can be understood from its name but not Dispatchers.IO or Dispatchers.Default. In that case you need to inject mainCoroutineRule.testDispatcher to your view model and use the injected dispatcher rather than hardcoding it.

The issue you are facing is because toList() needs the flow to complete and "State flow never completes" as per the documentation.

https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/

https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/to-list.html

SharedFlow/StateFlow is a hot flow, and as described in the docs, A shared flow is called hot because its active instance exists independently of the presence of collectors. It means, the scope that launches the collection of your flow won't complete by itself.

To solve this issue you need to cancel the scope in which the collect is called, and as the scope of your test is the test itself, its not ok to cancel the test, so what you need is launch it in a different job.

@Test
fun `Testing a integer state flow`() = runBlockingTest{
    val _intSharedFlow = MutableStateFlow(0)
    val intSharedFlow = _intSharedFlow.asStateFlow()
    val testResults = mutableListOf<Int>()

    val job = launch {
        intSharedFlow.toList(testResults)
    }
    _intSharedFlow.value = 5

    assertEquals(2, testResults.size)
    assertEquals(0, testResults.first())
    assertEquals(5, testResults.last())
    job.cancel()
}

Your specific use case:

@Test
fun `observe user wallets ok`() = runBlockingTest {
    whenever(api.getAssetWallets()).thenReturn(TestUtils.getAssetsWalletResponseOk())
    whenever(api.getFiatWallets()).thenReturn(TestUtils.getFiatWalletResponseOk())

    viewModel.getUserWallets()

    val result = arrayListOf<State<UserWallets>>()
    val job = launch {
        viewModel.userWallet.toList(result) //now it should work
    }

    Assertions.assertThat(viewModel.userWallet.value is State.Success).isTrue() //works, last value enmited
    Assertions.assertThat(result.first() is State.Success) //also works
    job.cancel()
}

Two important things:

1. Always cancel your created job to avoid java.lang.IllegalStateException: This job has not completed yet
2. As this is a StateFlow, when start collecting (inside toList) you receive the last state. But if you first start collecting and after you call your function viewModel.getUserWallets(), then inside the result list, you will have all the states, in case you want to test it too.

We can create a coroutine for given and one coroutine for whenever

after whenever code, we can use yield so our given code would be done and ready to assert!

to do that you need to extend CouroutinScope as you can see :

done!

• you can use emit instead of tryEmit