Question

我最近在我的Android项目中开始使用kotlin协同程序，但我有点问题。很多人会称它为代码味道。

我正在使用一个MVP架构，其协程在我的演示者中启动，如下所示：

// WorklistPresenter.kt
...
override fun loadWorklist() {
    ...
    launchAsync { mViewModel.getWorklist() }
    ...

launchAsync函数以这种方式实现（在我的WorklistPresenter类扩展的BasePresenter类中）：

@Synchronized
protected fun launchAsync(block: suspend CoroutineScope.() -> Unit): Job {
    return launch(UI) { block() }
}

问题在于我正在使用依赖于Android Framework的UI协程上下文。如果不进入ViewRootImpl$CalledFromWrongThreadException，我无法将其更改为另一个协程上下文。为了能够对此进行单元测试，我创建了一个BasePresenter的副本，其中包含launchAsync的不同实现：

protected fun launchAsync(block: suspend CoroutineScope.() -> Unit): Job {
    runBlocking { block() }
    return mock<Job>()
}

对我来说这是一个问题，因为现在我的BasePresenter必须在两个地方维护。所以我的问题是。如何更改我的实现以支持简单测试？

Answer 1

我建议将H5File file; auto file_id = file.getId(); H5IMmake_image_8bit(file_id, "Image1", width, height, data);逻辑提取到一个单独的类中，您可以在测试中简单地模拟它。

launchAsync

它应该是您的活动构造函数的一部分，以使其可替换。

Answer 2

我最近了解到Kotlin协程，教我的那个家伙向我展示了解决此问题的好方法。

您创建一个提供上下文的接口，并带有默认实现：

interface CoroutineContextProvider {
    val main: CoroutineContext
        get() = Dispatchers.Main
    val io: CoroutineContext
        get() = Dispatchers.IO

    class Default : CoroutineContextProvider
}

您可以手动（或使用注入框架）将此（CoroutineContextProvider.Default()）注入到presenter构造函数中。然后在您的代码中使用它提供的上下文：provider.main; provider.io;或您要定义的任何内容。现在，您可以在提供者对象中使用这些上下文来愉快地使用launch和withContext，知道它们将在您的应用程序中正常工作，但是您可以在测试期间提供不同的上下文。

从您的测试中注入该提供程序的不同实现，其中所有上下文均为Dispatchers.Unconfined

class TestingCoroutineContextProvider : CoroutineContextProvider {
    @ExperimentalCoroutinesApi
    override val main: CoroutineContext
        get() = Dispatchers.Unconfined
    @ExperimentalCoroutinesApi
    override val io: CoroutineContext
        get() = Dispatchers.Unconfined
}

当模拟暂停函数时，请用runBlocking对其进行包装，这将确保所有操作都在调用线程中进行（您的测试）。 here对此进行了说明（请参阅有关“无限制与受限分派器”的部分）。

Answer 3

您还可以让您的演示者不了解UI上下文。相反，演示者应该没有上下文。演示者应该只公开suspend函数并让调用者指定上下文。然后，当您从视图中调用此演示者协同程序函数时，可以使用UI上下文launch(UI) { presenter.somethingAsync() }来调用它。这样，在测试演示者时，您可以使用runBlocking { presenter.somethingAsync() }

运行测试

Answer 4

对于其他人来说，这是我最终实现的实现。

interface Executor {
    fun onMainThread(function: () -> Unit)
    fun onWorkerThread(function: suspend () -> Unit) : Job
}

object ExecutorImpl : Executor {
    override fun onMainThread(function: () -> Unit) {
        launch(UI) { function.invoke() }
    }

    override fun onWorkerThread(function: suspend () -> Unit): Job {
        return async(CommonPool) { function.invoke() }
    }
}

我在构造函数中注入Executor并使用kotlins委托来避免样板代码：

class SomeInteractor @Inject constructor(private val executor: Executor)
    : Interactor, Executor by executor {
    ...
}

现在可以交替使用Executor - 方法：

override fun getSomethingAsync(listener: ResultListener?) {
    job = onWorkerThread {
        val result = repository.getResult().awaitResult()
        onMainThread {
            when (result) {
                is Result.Ok -> listener?.onResult(result.getOrDefault(emptyList())) :? job.cancel()
                // Any HTTP error
                is Result.Error -> listener?.onHttpError(result.exception) :? job.cancel()
                // Exception while request invocation
                is Result.Exception -> listener?.onException(result.exception) :? job.cancel()
            }
        }
    }
}

在我的测试中，我使用此切换Executor实现。

对于单元测试：

/**
 * Testdouble of [Executor] for use in unit tests. Runs the code sequentially without invoking other threads
 * and wraps the code in a [runBlocking] coroutine.
 */
object TestExecutor : Executor {
    override fun onMainThread(function: () -> Unit) {
        Timber.d("Invoking function on main thread")
        function()
    }

    override fun onWorkerThread(function: suspend () -> Unit): Job {
        runBlocking {
            Timber.d("Invoking function on worker thread")
            function()
        }
        return mock<Job>()
    }
}

对于仪器测试：

/**
 * Testdouble of [Executor] for use in instrumentations tests. Runs the code on the UI thread.
 */
object AndroidTestExecutor : Executor {
    override fun onMainThread(function: () -> Unit) {
        Timber.d("Invoking function on worker thread")
        function()

    }

    override fun onWorkerThread(function: suspend () -> Unit): Job {
        return launch(UI) {
            Timber.d("Invoking function on worker thread")
            function()
        }
    }
}

Kotlin协程：在测试Android Presenter时切换上下文

4 个答案: