模拟改造挂起功能无限响应

Question

我想测试服务器没有返回响应的情况，我们触发下一个网络调用（例如搜索查询）。

所以我们基本上在 ViewModel 和 Retrofit 方法中都有一个方法

  interface RetrofitApi {
    @GET("Some Url")
    suspend fun getVeryImportantStuff(): String
}

class TestViewModel(private val api: RetrofitApi) : ViewModel() {

    private var askJob: Job? = null
    fun load(query: String) {
        askJob?.cancel()
        askJob = viewModelScope.launch {
            val response = api.getVeryImportantStuff()

            //DO SOMETHING WITH RESPONSE

        }
    }
}

并且我想在询问新查询时测试用例，而旧查询没有返回。 对于响应返回测试的情况很容易

@Test
    fun testReturnResponse() {
        runBlockingTest {
            //given
            val mockApi:RetrofitApi = mock()
            val viewModel = TestViewModel(mockApi)
            val response = "response from api"

            val query = "fancy query"
            whenever(mockApi.getVeryImportantStuff()).thenReturn(response)

            //when
            viewModel.load(query)


            //then
            //verify what happens
        }
    }

但我不知道如何模拟没有返回的挂起函数，以及像这样触发新请求时的测试用例

@Test
    fun test2Loads() {
        runBlockingTest {
            //given
            val mockApi:RetrofitApi = mock()
            val viewModel = TestViewModel(mockApi)
            val response = "response from api"
            val secondResponse = "response from api2"

            val query = "fancy query"
            whenever(mockApi.getVeryImportantStuff())
                .thenReturn(/* Here return some fancy stuff that is suspend* or something like onBlocking{} stub but not  blocking but dalayed forever/)
                .thenReturn(secondResponse)

            //when
            viewModel.load(query)
            viewModel.load(query)


            //then
            //verify that first response did not happens , and only second one triggered all the stuff
        }
    }

有什么想法吗？

编辑：我并不真正喜欢 mockito，任何模拟库都会很好:) 问候 沃伊泰克

Answer 1

我想出了解决问题的办法，但与我一开始的想法略有不同

        interface CoroutineUtils {
            val io: CoroutineContext
        }

        interface RetrofitApi {
            @GET("Some Url")
            suspend fun getVeryImportantStuff(query: String): String
        }

        class TestViewModel(private val api: RetrofitApi,
                            private val utils: CoroutineUtils) : ViewModel() {
        private val text = MutableLiveData<String>()
        val testStream: LiveData<String> = text
        private var askJob: Job? = null
        fun load(query: String) {
            askJob?.cancel()
            askJob = viewModelScope.launch {
                val response = withContext(utils.io) { api.getVeryImportantStuff(query) }
                text.postValue(response)
            }
        }
    }

测试场景应该是这样的

        class TestViewModelTest {

        @get:Rule
        val coroutineScope = MainCoroutineScopeRule()
        @get:Rule
        val instantTaskExecutorRule = InstantTaskExecutorRule()


        lateinit var retrofit: RetrofitApi

        lateinit var utils: CoroutineUtils

        val tottalyDifferentDispatcher = TestCoroutineDispatcher()

        lateinit var viewModel: TestViewModel
        @Before
        fun setup() {
            retrofit = mock()
            utils = mock()
            viewModel = TestViewModel(retrofit, utils)
        }


        @UseExperimental(ExperimentalCoroutinesApi::class)
        @Test
        fun test2Loads() {
            runBlockingTest {
                //given
                val response = "response from api"
                val response2 = "response from api2"
                val query = "fancy query"
                val query2 = "fancy query2"

                whenever(utils.io)
                    .thenReturn(tottalyDifferentDispatcher)

                val mutableListOfStrings = mutableListOf<String>()

                whenever(retrofit.getVeryImportantStuff(query)).thenReturn(response)
                whenever(retrofit.getVeryImportantStuff(query2)).thenReturn(response2)

                //when

                viewModel.testStream.observeForever {
                    mutableListOfStrings.add(it)
                }
                tottalyDifferentDispatcher.pauseDispatcher()
                viewModel.load(query)
                viewModel.load(query2)

                tottalyDifferentDispatcher.resumeDispatcher()

                //then
                mutableListOfStrings shouldHaveSize 1
                mutableListOfStrings[0] shouldBe response2
                verify(retrofit, times(1)).getVeryImportantStuff(query2)
            }
        }
    }

这不是我想要的，因为第一次调用 load 方法时不会触发改造调用，但它是最接近的解决方案。

对我来说完美的测试是断言改造被调用了两次，但只有第二次返回给 ViewModel。解决方案是将 Retrofit 包裹在返回挂起函数的方法周围

    interface RetrofitWrapper {
     suspend fun getVeryImportantStuff(): suspend (String)->String
    }
    class TestViewModel(private val api: RetrofitWrapper,
                        private val utils: CoroutineUtils) : ViewModel() {

        private val text = MutableLiveData<String>()
        val testStream: LiveData<String> = text
        private var askJob: Job? = null
        fun load(query: String) {
            askJob?.cancel()
            askJob = viewModelScope.launch {
                val veryImportantStuff = api.getVeryImportantStuff()
                val response = withContext(utils.io) {
                    veryImportantStuff(query)
                }
                text.postValue(response)
            }
        }
    }

并测试它

    @Test
    fun test2Loads() {
        runBlockingTest {
            //given
            val response = "response from api"
            val response2 = "response from api2"
            val query = "fancy query"
            val query2 = "fancy query2"

            whenever(utils.io)
                .thenReturn(tottalyDifferentDispatcher)

            val mutableListOfStrings = mutableListOf<String>()

            whenever(retrofit.getVeryImportantStuff())
                .thenReturn(suspendCoroutine {
                    it.resume { response }
                })
            whenever(retrofit.getVeryImportantStuff()).thenReturn(suspendCoroutine {
                it.resume { response2 }
            })

            //when

            viewModel.testStream.observeForever {
                mutableListOfStrings.add(it)
            }
            tottalyDifferentDispatcher.pauseDispatcher()
            viewModel.load(query)
            viewModel.load(query2)

            tottalyDifferentDispatcher.resumeDispatcher()

            //then
            mutableListOfStrings shouldHaveSize 1
            mutableListOfStrings[0] shouldBe response2
            verify(retrofit, times(2)).getVeryImportantStuff()
        }
    }

但在我看来，对代码的干扰有点太多了，只能进行测试。但也许我错了：P

Answer 2

当您有无法访问的服务器、超时或类似情况时，您似乎想要测试场景。

在这种情况下，在进行模拟时，您可以说第一次尝试返回对象，然后在第二次执行时抛出异常，例如 java.net.ConnectException: Connection timed out。

                whenever(mockApi.getVeryImportantStuff())
                .thenReturn(someObjet)
                .thenThrow(ConnectException("timed out"))

这应该可以，但你必须在 ViewModel 中执行 try/catch 块，这并不理想。我建议您添加额外的抽象。

您可以Repository 或UseCase 或您喜欢的任何模式/名称将网络呼叫移到那里。然后引入sealed class Result 来封装行为，让你的ViewModel 更具可读性。

class TestViewModel(val repo: Repo): ViewModel() {
    private var askJob: Job? = null

    fun load(query: String) {
        askJob?.cancel()
        askJob = viewModelScope.launch {
            when (repo.getStuff()) {
                is Result.Success -> TODO()
                is Result.Failure -> TODO()
            }
        }
    }
}

class Repo(private val api: Api) {
    suspend fun getStuff() : Result {
        return try {
            Result.Success(api.getVeryImportantStuff())
        } catch (e: java.lang.Exception) {
            Result.Failure(e)
        }
    }
}

sealed class Result {
    data class Success<out T: Any>(val data: T) : Result()
    data class Failure(val error: Throwable) : Result()
}

interface Api {
    suspend fun getVeryImportantStuff() : String
}

使用这种抽象级别，您的 ViewModelTest 只检查两种情况下发生的情况。

希望对你有帮助！