StateFlow测试仅获取最后状态，如何收集全部状态值？

StateFlow的核心特性是仅保留并发射最新状态，当在同一个协程中连续同步更新value时，中间状态会被后续的更新覆盖，最终只有最后一个状态会被下游收集到。你的ViewModel中loadExercise方法里连续设置_state.value = Loading、Data、Error，这些操作是同步执行的，没有挂起，StateFlow会直接合并这些更新，只保留最后一个Error状态。

方案1：改用SharedFlow（推荐，适配多状态序列场景） #

SharedFlow专门用于发射一系列事件/状态，不会合并连续的发射操作，适合需要跟踪完整状态变化序列的场景。

修改ViewModel代码：

@HiltViewModel
class ExerciseViewModel @Inject constructor(
    private val exerciseRepository: BaseRepository,
    private val exerciseMapper: ExerciseMapper
) : ViewModel() {

    private val _data = MutableStateFlow(Exercise())
    val data: StateFlow<Exercise> = _data.asStateFlow()
    // 替换为MutableSharedFlow，默认不重播，每次发射都会被下游收集
    private val _state = MutableSharedFlow<ExerciseViewState>()
    val state: SharedFlow<ExerciseViewState> = _state.asSharedFlow()

    fun loadExercise(id: Int) {
        viewModelScope.launch {
            _state.emit(ExerciseViewState.Loading) // 用emit发射状态
            try {
                val result = exerciseRepository.getExercise(id)
                _data.value = exerciseMapper.map(result)
                _state.emit(ExerciseViewState.Data)
                _state.emit(ExerciseViewState.Error)
            } catch (e: Exception) {
                _state.emit(ExerciseViewState.Error)
            }
        }
    }
}

修改测试代码：

@ExperimentalCoroutinesApi
class ExerciseViewModelTest {

    @get:Rule
    var rule = InstantTaskExecutorRule()

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private var exerciseRepository = FakeExerciseRepository()
    private var exerciseMapper = ExerciseMapper()
    lateinit var viewModel: ExerciseViewModel

    @Before
    fun setUp() {
        MockKAnnotations.init(this)
        viewModel = ExerciseViewModel(
            exerciseRepository = exerciseRepository,
            exerciseMapper = exerciseMapper
        )
    }

    @Test
    fun test() = runTest {
        val stateList = mutableListOf<ExerciseViewState>()
        // 启动协程收集所有发射的状态
        val job = launch {
            viewModel.state.collect { state ->
                stateList.add(state)
            }
        }
        viewModel.loadExercise(id = 1)
        advanceUntilIdle() // 等待所有协程执行完成
        // 验证完整状态序列
        assertContains(stateList, ExerciseViewState.Loading)
        assertContains(stateList, ExerciseViewState.Data)
        assertContains(stateList, ExerciseViewState.Error)
        job.cancel() // 取消收集协程
    }
}

方案2：保留StateFlow，添加临时挂起（仅测试用，不推荐生产环境） #

如果一定要用StateFlow，需要在每个状态更新之间加入短暂挂起，让StateFlow有时间将中间状态发射到下游：

修改ViewModel的loadExercise方法：

fun loadExercise(id: Int) {
    viewModelScope.launch {
        _state.value = ExerciseViewState.Loading
        delay(1) // 短暂挂起，确保状态被发射
        try {
            val result = exerciseRepository.getExercise(id)
            _data.value = exerciseMapper.map(result)
            _state.value = ExerciseViewState.Data
            delay(1)
            _state.value = ExerciseViewState.Error
        } catch (e: Exception) {
            _state.value = ExerciseViewState.Error
        }
    }
}

测试代码无需修改，此时stateList会收集到所有三个状态。但这种方法属于临时hack，生产环境不建议使用，因为delay会引入不必要的等待，且违背了StateFlow用于持有当前状态的设计初衷。

内容的提问来源于stack exchange，提问作者Mustafa Tatarhan