Testing Android ViewModels that use viewModelScope + Molecule may affect other tests

^{Originally posted by **mhernand40** September 18, 2022}
Been playing around with Molecule in my team's Android project by trying to introduce it as an implementation detail of two View Models; one that extends Jetpack's `ViewModel` and uses `viewModelScope`, and another that does not extend Jetpack's `ViewModel` and accepts any `CoroutineScope` via the constructor.

When it came to running the tests for each View Model, the tests passed when each test class was run in isolation. However, when running all the tests in one run, the test class for the View Model that extends Jetpack's `ViewModel` runs before the test class for the View Model that is a plain class, causing the latter's tests to fail.

It is worth noting the following:
* The tests use `runTest { … }` from the Coroutines Test library with the default `StandardTestDispatcher`,
* `viewModelScope` is used for the Jetpack `ViewModel`
* Requires `Dispatchers.setMain(…)`/`Dispatchers.resetMain()`
* the tests do not explicitly clear the `ViewModel`
* the tests do not explicitly cancel `viewModelScope`
* `TestScope(testScheduler)` is used for the View Model that does not extend Jetpack's `ViewModel`
* No usage of `Dispatchers.setMain(…)`/`Dispatchers.resetMain()`

I have reduced the repro down to the following test class (no Jetpack `ViewModel` required):
```Kotlin
internal class Repro {

// This test passes but causes the next test to fail.
@Test
fun test1() {
try {
Dispatchers.setMain(StandardTestDispatcher())
runTest {
val moleculeScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
doRunTest(moleculeScope)
// moleculeScope.cancel() // Uncommenting this fixes the test2 failure.
}
} finally {
Dispatchers.resetMain()
}
}

// This test only passes when run by itself or if it runs before test1.
// If you rename this to test0 so that it runs before test1, it will pass.
@Test
fun test2() = runTest {
val moleculeScope = TestScope(testScheduler)
doRunTest(moleculeScope)
}

private fun TestScope.doRunTest(moleculeScope: CoroutineScope) {
val event = MutableSharedFlow(extraBufferCapacity = 1)
val state = moleculeScope.launchMolecule(RecompositionClock.Immediate) {
var value by remember { mutableStateOf("") }
LaunchedEffect(event) { event.collect { value = it } }
value
}
runCurrent()
event.tryEmit("test")
runCurrent()
assertEquals("test", state.value)
}
}
```

`test1` simulates the scenario when testing a Jetpack `ViewModel` that uses `viewModelScope`.