原生移动开发 / 系统课时

ViewModel 与 Repository 测试

ViewModel 与 Repository 测试

ViewModel 与 Repository 测试的关键不是堆 Mock,而是切清测试边界:ViewModel 只验证状态发布和调用行为,Repository 只验证数据访问与转换规则。本课用可控 Fake 和协程测试调度器,把成功、失败与加载状态变成确定可复现的测试。

学习目标

  • 能用 Fake 替代 Repository 或下游数据源,隔离被测对象
  • 能用 runTest、测试调度器和虚拟时间验证协程状态变化
  • 能分别验证 ViewModel 状态逻辑与 Repository 数据转换逻辑

先划分两个测试边界

测试 ViewModel 时,让 Fake Repository 直接返回受控数据或错误,避免把网络、数据库和序列化问题混进状态测试。测试 Repository 时,则把 API 或 DAO 换成 Fake 数据源,只验证 Repository 是否正确调用下游并完成必要转换。

ViewModel 与 Repository 的测试边界

本地 JVM 测试需要 JUnit;协程测试还需要 kotlinx-coroutines-test。下面示例使用 JUnit 4 和协程测试库,应用本身需已经包含 ViewModel 相关依赖。

kotlin
dependencies {
    testImplementation("junit:junit:4.13.2")
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2")
}

用可控替身驱动状态和数据逻辑

下面的测试文件同时演示两个边界:DefaultArticleRepository 使用 Fake API 验证数据清洗,ArticleViewModel 使用 Fake Repository 验证加载成功和失败状态。生产项目中应把接口与实现放回 src/main,这里只为让示例完整可读。

kotlin
package com.example.testing

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runCurrent
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Rule
import org.junit.Test
import org.junit.rules.TestWatcher
import org.junit.runner.Description

interface ArticleApi {
    suspend fun fetchTitle(): String
}

interface ArticleRepository {
    suspend fun loadTitle(): String
}

class DefaultArticleRepository(
    private val api: ArticleApi
) : ArticleRepository {
    override suspend fun loadTitle(): String = api.fetchTitle().trim()
}

class RepositoryException(message: String) : RuntimeException(message)

data class ArticleUiState(
    val loading: Boolean = false,
    val title: String? = null,
    val error: String? = null
)

class ArticleViewModel(
    private val repository: ArticleRepository
) : ViewModel() {
    private val _state = MutableStateFlow(ArticleUiState())
    val state: StateFlow<ArticleUiState> = _state.asStateFlow()

    fun load() {
        viewModelScope.launch {
            _state.value = ArticleUiState(loading = true)
            _state.value = try {
                ArticleUiState(title = repository.loadTitle())
            } catch (e: RepositoryException) {
                ArticleUiState(error = e.message ?: "unknown")
            }
        }
    }
}

class FakeArticleApi(private val title: String) : ArticleApi {
    override suspend fun fetchTitle(): String = title
}

class FakeArticleRepository(
    private val title: String = "",
    private val error: RepositoryException? = null
) : ArticleRepository {
    var calls: Int = 0
        private set

    override suspend fun loadTitle(): String {
        calls++
        delay(10) // 制造可控挂起点,便于观察 loading 状态。
        error?.let { throw it }
        return title
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class MainDispatcherRule(
    val dispatcher: TestDispatcher = StandardTestDispatcher()
) : TestWatcher() {
    override fun starting(description: Description) {
        Dispatchers.setMain(dispatcher)
    }

    override fun finished(description: Description) {
        Dispatchers.resetMain()
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class ArticleViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    @Test
    fun repositoryTrimsApiValue() = runTest {
        val repository = DefaultArticleRepository(
            FakeArticleApi("  Android Testing  ")
        )

        assertEquals("Android Testing", repository.loadTitle())
    }

    @Test
    fun viewModelPublishesLoadingThenData() = runTest {
        val fakeRepository = FakeArticleRepository(title = "Android Testing")
        val viewModel = ArticleViewModel(fakeRepository)

        viewModel.load()
        runCurrent()
        assertTrue(viewModel.state.value.loading)

        // 推进虚拟时间,完成 Fake Repository 中的 delay。
        advanceUntilIdle()
        assertEquals(
            ArticleUiState(title = "Android Testing"),
            viewModel.state.value
        )
        assertEquals(1, fakeRepository.calls)
    }

    @Test
    fun viewModelPublishesRepositoryError() = runTest {
        val viewModel = ArticleViewModel(
            FakeArticleRepository(
                error = RepositoryException("offline")
            )
        )

        viewModel.load()
        advanceUntilIdle()

        assertEquals("offline", viewModel.state.value.error)
    }
}

Fake 的职责只有两类:提供确定输入,以及记录是否被调用。不要把缓存、重试、线程切换等生产逻辑复制到 Fake 里,否则测试会开始验证“假实现”,而不是验证真实对象的行为。

用虚拟时间代替真实等待

viewModelScope 依赖主调度器,本地 JVM 测试没有真实 Android Main Looper,因此测试规则先用 Dispatchers.setMain 替换主调度器。runCurrent() 执行当前已经排队的任务,适合观察中间的 loading;advanceUntilIdle() 会推进虚拟时间直到所有待执行协程结束。

这种方式比 Thread.sleep() 稳定得多:测试不依赖机器速度,也不需要真的等待 10 毫秒。若测试一直停在初始状态,优先检查 Main 调度器是否已替换,以及是否忘了推进测试调度器。

运行并验证两个边界

在项目根目录运行该测试类:

bash
./gradlew testDebugUnitTest --tests "*ArticleViewModelTest"

预期输出:

text
> Task :app:testDebugUnitTest
BUILD SUCCESSFUL in <TIME>

<TIME> 和 Gradle 的附加任务行会因环境不同而变化。这里的通过条件不是“调用了某个实现细节”,而是 Repository 得到预期转换结果、ViewModel 发布了正确状态,并且依赖调用次数符合契约。

当 ViewModel 和 Repository 分开测试后,失败信号会更清楚:状态断言失败优先看 ViewModel,数据转换失败优先看 Repository。测试替身只负责隔离边界,协程测试工具只负责让时间和调度可控,两者结合才能得到稳定、可维护的本地单元测试。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

ViewModel 与 Repository 测试

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通