Im trying to test a ViewModel that lazily loads data when the LiveData is accessed and first emits a Loading state, the loads the data, then emits a Data state with the result. The data is loaded in a coroutine on the viewModelScope and I’m using TestCoroutineScope and MockK in my test but for some reason my mock observer doesn’t get the loading emission unless I pause the dispatcher then resume it. Here’s a basic example of my issue

// The view model 
class LazyViewModel(val repo: Repo) : ViewModel() {
    val state: LiveData<State<String>> by lazy {
        loadData()
        _state
    }

    private val _state = MutableLiveData<State<String>>()
    private fun loadData() {
        viewModelScope.launch {
            _state.value = State.Loading
            _state.value = State.Data(repo.getData())
        }
    }
}
// the test
    @Test
    fun `get loading then data`() = coroutinesTestRule.testScope.runBlockingTest {
        val mockObserver: Observer<State<String>> = mockk(relaxUnitFun = true)

        val mockRepo: Repo = mockk {
            coEvery { getData() } returns "data"
        }
        val viewModel = LazyViewModel(mockRepo)
        // If I don't pause then resume the dispatcher _state.value = State.Loading seemingly gets skipped
        pauseDispatcher()
        viewModel.state.observeForever(mockObserver)
        resumeDispatcher()
        verifyOrder {
            mockObserver.onChanged(State.Loading)
            mockObserver.onChanged(State.Data("data"))
        }
    }

I dont see where you've replaced your viewModelScope with a TestCoroutineScope...?

Is that the issue? Do you have to inject a CoroutineScope to ViewModels instead of using viewModelScope directly? My coroutine test rule sets main and follows the example here

Im not sure if you have to but its what i've been doing and it seems to work 🤷 Instead of injecting it you could consider doing something like this:

open class MyViewModel {
    protected open val mScope = CoroutineScope(Dispatchers.Main)
}

and then in tests use:

class MyViewModelStub : MyViewModel {
	override val mScope = TestCoroutineScope()
}

So that just doesn't use the viewModelScope extension provided by android? I feel like there has to be a way to utilize androids extension

You can use viewModelScope if you want:

open class MyViewModel {
    protected open val mScope = viewModelScope
}

Also something I've noticed is that if instead of calling loadData in the lazy block you call it manually from the test it works as expected