android/.claude/skills/testing-android-code/examples/viewmodel-test-example.md

/**
 * Complete ViewModel Test Example
 *
 * Key patterns demonstrated:
 * - Extending BaseViewModelTest
 * - Testing StateFlow with Turbine
 * - Testing EventFlow with Turbine
 * - Using stateEventFlow() for simultaneous testing
 * - MockK mocking patterns
 * - Test factory method design (accepts domain state, not SavedStateHandle)
 * - Complete state assertions (assert entire state objects)
 */
package com.bitwarden.example.feature

import androidx.lifecycle.SavedStateHandle
import app.cash.turbine.test
import com.bitwarden.ui.platform.base.BaseViewModelTest
import io.mockk.coEvery
import io.mockk.coVerify
import io.mockk.every
import io.mockk.mockk
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test

class ExampleViewModelTest : BaseViewModelTest() {

    // Mock dependencies
    private val mockRepository: ExampleRepository = mockk()
    private val mockAuthDiskSource: AuthDiskSource = mockk {
        every { userStateFlow } returns MutableStateFlow(null)
    }

    /**
     * StateFlow has replay=1, so first awaitItem() returns current state
     */
    @Test
    fun `initial state should be default state`() = runTest {
        val viewModel = createViewModel()

        viewModel.stateFlow.test {
            assertEquals(DEFAULT_STATE, awaitItem())
        }
    }

    /**
     * Test state transitions: initial -> loading -> success
     */
    @Test
    fun `LoadData action should update state from idle to loading to success`() = runTest {
        val expectedData = "loaded data"
        coEvery { mockRepository.fetchData(any()) } returns Result.success(expectedData)

        val viewModel = createViewModel()

        viewModel.stateFlow.test {
            assertEquals(DEFAULT_STATE, awaitItem())

            viewModel.trySendAction(ExampleAction.LoadData)

            assertEquals(DEFAULT_STATE.copy(isLoading = true), awaitItem())
            assertEquals(DEFAULT_STATE.copy(isLoading = false, data = expectedData), awaitItem())
        }

        coVerify { mockRepository.fetchData(any()) }
    }

    /**
     * EventFlow has no replay - MUST call expectNoEvents() first
     */
    @Test
    fun `SubmitClick action should emit NavigateToNext event`() = runTest {
        coEvery { mockRepository.submitData(any()) } returns Result.success(Unit)

        val viewModel = createViewModel()

        viewModel.eventFlow.test {
            expectNoEvents() // CRITICAL for EventFlow
            viewModel.trySendAction(ExampleAction.SubmitClick)
            assertEquals(ExampleEvent.NavigateToNext, awaitItem())
        }
    }

    /**
     * Use stateEventFlow() helper for simultaneous testing
     */
    @Test
    fun `complex action should update state and emit event`() = runTest {
        coEvery { mockRepository.complexOperation(any()) } returns Result.success("result")

        val viewModel = createViewModel()

        viewModel.stateEventFlow(backgroundScope) { stateFlow, eventFlow ->
            assertEquals(DEFAULT_STATE, stateFlow.awaitItem())
            eventFlow.expectNoEvents()

            viewModel.trySendAction(ExampleAction.ComplexAction)

            assertEquals(DEFAULT_STATE.copy(isLoading = true), stateFlow.awaitItem())
            assertEquals(DEFAULT_STATE.copy(data = "result"), stateFlow.awaitItem())
            assertEquals(ExampleEvent.ShowToast("Success!"), eventFlow.awaitItem())
        }
    }

    /**
     * Test state restoration from saved state.
     * Note: Use initialState parameter, NOT SavedStateHandle directly.
     */
    @Test
    fun `initial state from saved state should be preserved`() = runTest {
        // Build complete expected state - always assert full objects
        val savedState = ExampleState(
            isLoading = false,
            data = "restored data",
            errorMessage = null,
        )

        val viewModel = createViewModel(initialState = savedState)

        viewModel.stateFlow.test {
            assertEquals(savedState, awaitItem())
        }
    }

    /**
     * Factory method accepts domain state, NOT SavedStateHandle.
     * This hides Android framework details from test logic.
     */
    private fun createViewModel(
        initialState: ExampleState? = null,
    ): ExampleViewModel = ExampleViewModel(
        savedStateHandle = SavedStateHandle().apply { set("state", initialState) },
        repository = mockRepository,
        authDiskSource = mockAuthDiskSource,
    )
}

private val DEFAULT_STATE = ExampleState(
    isLoading = false,
    data = null,
    errorMessage = null,
)

// Example types (normally in separate files)
data class ExampleState(
    val isLoading: Boolean = false,
    val data: String? = null,
    val errorMessage: String? = null,
)

sealed class ExampleAction {
    data object LoadData : ExampleAction()
    data object SubmitClick : ExampleAction()
    data object ComplexAction : ExampleAction()
}

sealed class ExampleEvent {
    data object NavigateToNext : ExampleEvent()
    data class ShowToast(val message: String) : ExampleEvent()
}