测试无限Kotlin Coroutine

Question

我有一个ViewModel。当它在屏幕上可见时，它就开始了。当用户离开屏幕时，它会停止。在启动ViewModel时，我想每5秒执行一些代码。该代码看起来有点像这样：

fun onStart() {
    interval = launch(injectedDispatcher) {
        while (true) {
            doSomething()
            delay(5000.milliseconds)
        }
    }
}

fun onStop() {
    interval.cancel()
}

我想编写一个集成测试，该测试将与其依赖关系一起测试此视图模型。我使用TestScope即时进行此集成测试：

val scope = TestScope()
val injectedDispatcher = StandardTestDispatcher(scope.testScheduler)

@Test
fun interval() = scope.runTest {
   val viewModel = get(injectedDispatcher)
   viewModel.onStart()
   delay(30000) // <- execution will get stuck at this point
   assertSomething(...)
   viewModel.onStop()
}

如果对测试的代码中没有无限循环，则此测试代码运行良好。但是，如果至少有一个无限的Coroutine，则延迟（30000）将永远不会退出。取而代之的是，即使经过30000ms之后，执行将被卡在中，而（true）循环。我还验证了scope.currenttime可以超过30000ms的增加，而while loop仍然不会退出。

我认为这是因为StandardTestDisPatcher会在循环内部骑自行车，因为它一旦开始就无法暂停工作。

我做了一个小例子来说明问题： https://github.com/alexey-com/alexey-/alexey-/infinetetestest < /a>

是否有一种方法可以使用TestDisPatcher在特定时间内暂停无限循环？

Answer 1

问题似乎是testscope.runtest将等待所有儿童coroutines在提供测试结果之前完成。
执行不会陷入延迟（30_000）中。导致测试永远运行的原因是，您的断言失败并抛出了essertionError。由于抛出了错误，因此从未调用下一行viewModel.onstop（）。这意味着您在ViewModel中启动的Coroutine永远不会完成，因此testscope.runtest永远不会提供结果。
您可以轻松测试：

...
println("after delay; before assertion")
try{
    assertEquals(6, viewModel.count)
}catch (e: AssertionError){
    e.printStackTrace()
    throw e
}
println("after assertion")
viewModel.onStop()

最简单的解决方案是首先调用viewmodel.onstop（），然后运行您想要的任何断言。

---

如果您关心一种完全替代方法，则可以避免完全手动开始和停止视图模式，然后选择更“ coroutine-y”的方法：

class AndroidTestViewModel(
    val injectedDispatcher: CoroutineDispatcher = Dispatchers.IO
) : ViewModel() {
    var count = 0

    suspend fun doWhileInForeground(){
        withContext(injectedDispatcher){
            while (true) {
                delay(5000)
                count++
            }
        }
    }
}

测试这可能会更像是这样：

@Test
fun interval() = scope.runTest {
    val viewModel = AndroidTestViewModel(injectedDispatcher)
    launch {
        viewModel.doWhileInForeground()
    }
    delay(30_000)
    assertEquals(6,viewModel.count)
}

并且在片段中使用了一个示例，这很容易适应活动或JetPack组成：

class SampleFragment: Fragment(){
    val viewModel: AndroidTestViewModel = TODO()
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        viewLifecycleOwner.lifecycleScope.launch { 
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED){
                viewModel.doWhileInForeground()
            }
        }
    }
}

Answer 2

什么是StandardTestDisPatcher和TestScope？一个写了我的意见。所有工作。

测试看起来像。

val scope = TestScope()
val injectedDispatcher = StandardTestDispatcher(scope.testScheduler)
val model = TestViewModel()

@Test
fun interval() = scope.runTest {
    val viewModel = model
    viewModel.injectedDispatcher = injectedDispatcher
    viewModel.onStart()
    delay(30000) // <- execution will get stuck at this point   
    viewModel.onStop()
    Assert.assertTrue(model.count > 0)
}

模型看起来像是

var injectedDispatcher = Dispatchers.IO
var interval: Job? = null

var count = 0

fun onStart() {
    interval = viewModelScope.launch(injectedDispatcher) {
        while (true) {
            delay(5000)
            count++
        }
    }
}

fun onStop() {
    interval?.cancel()
}

这样的决定是当所有作业关闭时确定结果。当我们有断言错误时，我们会退出测试。范围正在工作，测试无法完成。

@Test
fun interval() = scope.runTest {
    val viewModel = get(injectedDispatcher)
    viewModel.onStart()
    delay(30000) // <- execution will get stuck at this point
    val result = getFromSomeWere() // <- what we wanna check
    viewModel.onStop()
    assertSomething(...) // <- check it here
}

或者

@Test
fun androidInterval() = scope.runTest {
    val viewModel = AndroidTestViewModel(injectedDispatcher)
    try {
        viewModel.onStart()
        delay(30000)
        assertEquals(6, viewModel.count)
    } catch (e: AssertionError) {
        viewModel.onStop()
        throw e
    }
    viewModel.onStop()
}