Android 테스트: Mock 대신 Fake로 상태 검증하기

호출을 검증하는 Mock 테스트는 동작이 그대로여도 구현이 바뀌면 깨져요. Fake로 상태를 검증하는 방법과 코루틴 코드를 테스트할 때 디스패처를 다루는 방법을 정리했어요.

화면은 그대로 잘 동작하는데 리팩터링을 하고 나니 테스트가 실패하는 경우가 있어요. 테스트가 결과 대신 구현 방식을 확인하고 있으면 이런 일이 생겨요. 이 글에서는 Mock으로 호출을 검증하는 테스트가 어떻게 깨지는지 보고 Fake로 상태를 검증하는 테스트로 바꾸는 방법과 코루틴 코드를 테스트할 때 필요한 도구를 정리해요.

코드는 lifecycle 2.11.0, kotlinx-coroutines-test 1.11.0, Turbine 1.2.1, Mockito 5.24.0 기준이에요. 모두 Android 라이브러리 모듈의 로컬 테스트로 실행해 확인했어요.

1. 호출을 검증하는 테스트의 한계

예시는 사용자 한 명을 불러와 화면 상태로 바꾸는 ViewModel이에요.

kotlin
data class User(val id: String, val name: String)

interface UserRepository {
    fun getUser(userId: String): Flow<Result<User>>
    suspend fun saveUser(user: User)
}

sealed interface UiState {
    data object Loading : UiState
    data class Success(val data: User) : UiState
    data class Error(val message: String) : UiState
}

class UserViewModel(
    private val userRepository: UserRepository,
) : ViewModel() {
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    fun loadUser(userId: String) {
        viewModelScope.launch {
            userRepository.getUser(userId).collect { result ->
                _uiState.value = result.fold(
                    onSuccess = { UiState.Success(it) },
                    onFailure = { UiState.Error(it.message.orEmpty()) },
                )
            }
        }
    }
}

Mockito로 이 ViewModel을 테스트하면 이렇게 쓸 수 있어요. UserRepository가 돌려줄 값을 정해 두고 loadUser가 getUser를 한 번 불렀는지 verify로 확인해요. MainDispatcherRule은 5절에서 설명해요.

kotlin
class UserViewModelMockTest {
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private val userRepository = Mockito.mock(UserRepository::class.java)

    @Test
    fun loadUser_callsRepositoryOnce() {
        Mockito.`when`(userRepository.getUser("user_1"))
            .thenReturn(flowOf(Result.success(User(id = "user_1", name = "Mingyu"))))
        val viewModel = UserViewModel(userRepository)

        viewModel.loadUser("user_1")

        Mockito.verify(userRepository, Mockito.times(1)).getUser("user_1")
    }
}

이 테스트는 통과해요. 이제 화면이 받는 상태는 그대로 두고 ViewModel만 stateIn으로 상태를 만드는 형태로 바꿔요. Now in Android의 ViewModel들이 쓰는 형태예요. Result를 UiState로 바꾸는 부분은 1절과 같아서 줄였어요.

kotlin
@OptIn(ExperimentalCoroutinesApi::class)
class UserViewModel(
    private val userRepository: UserRepository,
) : ViewModel() {
    private val userId = MutableStateFlow<String?>(null)

    val uiState: StateFlow<UiState> = userId
        .filterNotNull()
        .flatMapLatest { id -> userRepository.getUser(id) }
        .map { result ->
            // ...
        }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), UiState.Loading)

    fun loadUser(userId: String) {
        this.userId.value = userId
    }
}

바꾼 뒤 같은 테스트를 돌리면 WantedButNotInvoked로 실패해요. SharingStarted.WhileSubscribed는 uiState를 구독하는 쪽이 생겨야 getUser를 부르는 Flow를 시작해요. 이 테스트는 uiState를 구독하지 않아서 getUser가 불리지 않았어요. 실제 화면은 uiState를 구독하니 사용자가 보는 결과는 똑같아요. 동작은 그대로인데 테스트만 깨졌어요.

공식 문서는 Mock을 어떤 호출을 받을지 기대가 정해진 테스트 더블로 설명해요. 그래서 Mock으로 쓴 테스트는 결과보다 호출 방식에 묶이고, 호출 방식을 바꾸는 리팩터링을 할 때마다 같이 고쳐야 해요.

2. 테스트용으로 만든 가벼운 구현, Fake

Android 공식 문서는 테스트 더블을 여섯 가지로 나눠요.

종류설명
Fake테스트에 맞게 단순하게 만든, 실제로 동작하는 구현. 예: 인메모리 데이터베이스
Mock정해 둔 대로 동작하며 호출이 기대와 다르면 테스트를 실패시키는 객체. 예: 메서드가 정확히 한 번 불렸는지 확인
Stub정해 둔 대로 동작하지만 호출을 검증하지는 않는 객체
Dummy인자를 채우려고 넘기기만 하고 쓰지 않는 객체
Spy실제 객체를 감싸고 호출 기록 같은 추가 정보를 함께 남기는 객체
ShadowRobolectric에서 쓰는 Fake

이 중 공식 문서가 권하는 것은 Fake예요. Fake는 실제로 동작하지만 테스트에 맞게 단순하게 만들어서 프로덕션에는 쓸 수 없는 구현이에요. Mocking 프레임워크가 필요 없고 가벼워요. Now in Android의 테스트 전략 문서는 아예 Mocking 프레임워크를 쓰지 않고 Fake를 쓴다고 정해 두었어요.

3. Fake로 상태를 검증하기

Fake를 쓰면 함수가 불렸는지 대신 상태가 기대한 대로 바뀌었는지를 확인할 수 있어요. 1절의 UserViewModel을 Fake로 다시 테스트해요.

의존성을 인터페이스로 받기

UserViewModel은 생성자로 UserRepository 인터페이스를 받아요. 그래서 테스트에서는 실제 구현 대신 Fake를 넘길 수 있어요. 공식 문서가 테스트하기 쉬운 구조를 만드는 방법으로 드는 네 가지 중 하나예요. 나머지 셋은 레이어나 기능별 모듈로 나누기, Activity와 Fragment에 로직을 넣지 않기, 비즈니스 로직이 프레임워크에 직접 의존하지 않게 하기예요. 인터페이스를 쓰고 의존성 주입(DI)을 쓰는 건 DI 프레임워크가 없어도 할 수 있어요.

Fake 만들기

Fake는 test 소스 세트에 둬서 앱과 함께 배포되지 않게 해요. 여러 모듈의 테스트가 같은 Fake를 쓴다면 Now in Android처럼 테스트 전용 모듈(core:testing)을 만들고 각 모듈이 testImplementation으로 가져다 써요.

kotlin
class FakeUserRepository : UserRepository {
    private val users = MutableStateFlow<List<User>>(emptyList())

    override fun getUser(userId: String): Flow<Result<User>> =
        users.map { list ->
            list.find { it.id == userId }
                ?.let { Result.success(it) }
                ?: Result.failure(NoSuchElementException("No user: $userId"))
        }

    override suspend fun saveUser(user: User) {
        users.update { current -> current.filterNot { it.id == user.id } + user }
    }
}

데이터는 MutableStateFlow에 담긴 리스트예요. 데이터베이스나 네트워크 없이 메모리에서만 동작해요. saveUser로 넣은 사용자를 getUser가 돌려줘요.

테스트 작성

Flow로 나오는 상태는 Turbine으로 확인해요. test {} 안에서 awaitItem()을 부르면 값이 나온 순서대로 하나씩 받아요. Turbine은 별도 라이브러리라 의존성을 추가해야 해요. Mockito는 1절과 4절의 예시에만 필요해요.

kotlin
dependencies {
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.11.0")
    testImplementation("app.cash.turbine:turbine:1.2.1")
    testImplementation("org.mockito:mockito-core:5.24.0")
}
kotlin
class UserViewModelFakeTest {
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    @Test
    fun loadUser_whenUserExists_showsUser() = runTest {
        val repository = FakeUserRepository()
        repository.saveUser(User(id = "user_1", name = "Mingyu"))
        val viewModel = UserViewModel(repository)

        viewModel.uiState.test {
            assertEquals(UiState.Loading, awaitItem())

            viewModel.loadUser("user_1")

            val state = awaitItem() as UiState.Success
            assertEquals("Mingyu", state.data.name)
        }
    }
}

when도 verify도 없어요. 저장해 둔 사용자가 화면 상태로 나오는지만 확인해요. 없는 사용자를 찾으면 에러 상태가 되는지도 같은 방식으로 확인해요. 첫 awaitItem()이 Loading인 이유는 StateFlow가 새 구독자에게 현재 값을 바로 보내기 때문이에요. runTest는 5절에서 설명해요.

1절처럼 ViewModel을 stateIn 형태로 바꿔도 이 테스트는 그대로 통과해요. Turbine의 test {}가 uiState를 구독하고, 호출 대신 상태를 확인하기 때문이에요.

4. Stub 대신 Fake를 쓰는 이유

3절의 테스트가 리팩터링을 버틴 이유는 Fake 자체보다 상태를 확인했다는 데 있어요. 1절의 Mock 테스트에서 verify를 빼고 getUser의 반환값만 정해 둔 Stub으로 넘긴 뒤, 3절처럼 Turbine으로 상태를 확인해도 stateIn 버전에서 통과해요.

그래도 저는 Stub보다 Fake를 쓰는 편이 낫다고 생각해요.

  1. 프레임워크가 필요 없음: Fake는 평범한 Kotlin 클래스예요. 공식 문서도 단순하다는 이유로 Stub보다 Fake를 권해요.
  2. 저장과 조회가 맞물림: Stub은 호출마다 돌려줄 값을 하나씩 정해야 해요. Fake는 saveUser로 넣은 사용자를 getUser가 돌려주니, 테스트를 저장하고 불러오는 흐름 그대로 쓸 수 있어요.

다만 Fake의 로직은 테스트용으로 단순하게 만든 것이라 실제 UserRepository 구현까지 검증하지는 않아요. 실제 구현은 그 구현의 테스트에서 따로 확인해야 해요.

5. 코루틴 테스트

코루틴을 쓰는 코드는 비동기로 여러 스레드에서 돌 수 있어서, kotlinx-coroutines-test의 도구로 실행 시점을 제어해요.

runTest

runTest는 테스트용 코루틴 빌더예요. runBlocking과 달리 가상 시간을 써서 delay()를 실제로 기다리지 않고 건너뛰어요. delay(1_000L)을 부르는 함수를 runTest 안에서 실행하면 바로 끝나고, 가상 시간을 나타내는 currentTime은 1,000을 가리켜요.

두 가지 TestDispatcher

테스트 안에서 새 코루틴이 언제 실행될지는 TestDispatcher가 정해요. 두 가지가 있어요.

StandardTestDispatcher는 runTest의 기본값이에요. 새 코루틴을 스케줄러의 대기열에 넣어 두고 테스트 스레드가 양보할 때 실행해요. advanceUntilIdle(), advanceTimeBy(), runCurrent()를 부르거나 join()으로 기다리면 양보하게 돼요. 끝까지 양보하지 않으면 새 코루틴은 테스트 본문이 끝난 뒤, runTest가 반환되기 전에야 실행돼요.

UnconfinedTestDispatcher는 새 코루틴을 바로 시작해요. 다만 끝까지 바로 실행하지는 않아요. 코루틴이 delay처럼 중단되는 지점을 만나면 그 뒤는 다른 코루틴과 마찬가지로 스케줄러에서 차례를 기다려요. 공식 문서는 간단한 테스트에는 UnconfinedTestDispatcher가 편하다고 해요. 다만 실제 디스패처와 동작이 달라서 동시성을 검증하는 테스트에는 StandardTestDispatcher를 쓰라고 해요.

디스패처를 주입받기

프로덕션 코드에서 withContext(Dispatchers.IO)처럼 디스패처를 직접 쓰면 테스트에서 바꿀 수 없어요. 생성자로 디스패처를 받게 하면 테스트에서 TestDispatcher를 넘길 수 있어요. 기본값을 Dispatchers.IO로 두면 프로덕션 코드에서는 따로 넘기지 않아도 돼요.

kotlin
class UserFileStore(
    private val file: File,
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
) {
    suspend fun readName(): String = withContext(ioDispatcher) {
        file.readText()
    }
}

테스트에서는 StandardTestDispatcher를 만들어 넘기는데, 이때 runTest의 testScheduler를 같이 넘겨요. 공식 문서는 한 테스트에서 쓰는 TestDispatcher가 모두 스케줄러 하나를 같이 써야 한다고 해요.

이렇게 주입하면 withContext 안의 코드도 테스트 스레드에서 돌고, 그 안에 delay가 있으면 가상 시간으로 건너뛰어요. Dispatchers.IO를 그대로 쓰면 다른 스레드에서 돌고 delay도 실제로 기다려요.

Dispatchers.Main 바꾸기

로컬 테스트는 개발 PC의 JVM에서 실행돼요. 그래서 Android UI 스레드를 감싼 Main 디스패처가 없어요. 공식 문서는 테스트할 코드가 Main을 쓰면 예외가 난다고 해요. kotlinx-coroutines-test가 있는 로컬 테스트에서는 setMain 없이 Dispatchers.Main.immediate를 읽으면 IllegalStateException이 나요.

viewModelScope는 조금 달라요. lifecycle 2.11.0의 viewModelScope는 Dispatchers.Main.immediate를 읽다가 IllegalStateException이 나면 예외를 내지 않고 EmptyCoroutineContext로 대신해요. 규칙 없이 1절의 첫 번째 UserViewModel을 테스트하면 loadUser의 코루틴이 Dispatchers.Default의 스레드에서 돌아요. loadUser를 부른 직후의 상태는 대개 아직 Loading이고, 언제 Success로 바뀌는지는 스레드 타이밍에 달려 있어요. 이래서는 믿을 수 있는 테스트가 되지 않아요.

로컬 테스트에서는 Dispatchers.Main을 TestDispatcher로 바꿔요. 테스트마다 직접 바꾸는 대신 JUnit 규칙으로 만들어 두고 쓰는 방식을 흔히 써요. 아래 코드는 공식 문서와 Now in Android의 MainDispatcherRule과 같은 형태이고, JUnit 4의 TestWatcher를 써요.

kotlin
@OptIn(ExperimentalCoroutinesApi::class)
class MainDispatcherRule(
    val testDispatcher: TestDispatcher = UnconfinedTestDispatcher(),
) : TestWatcher() {
    override fun starting(description: Description) {
        Dispatchers.setMain(testDispatcher)
    }

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

테스트 클래스에서는 @get:Rule val mainDispatcherRule = MainDispatcherRule() 한 줄이면 돼요. 1절과 3절의 테스트가 이렇게 썼어요.

setMain, resetMain, UnconfinedTestDispatcher는 kotlinx-coroutines-test 1.11.0에서도 @ExperimentalCoroutinesApi라서 @OptIn을 붙였어요.

이 규칙은 로컬 테스트에서만 써요. 실제 UI 스레드가 있는 계측 테스트에서는 Main 디스패처를 바꾸지 않아요.

마무리

저는 테스트가 확인할 것은 사용자가 보게 될 상태라고 생각해요. 그래서 직접 만든 Repository처럼 인터페이스로 받는 의존성은 Fake로, 라이브러리나 프레임워크의 타입은 그 라이브러리가 공식으로 제공하는 테스트 도구로 테스트하기를 권해요.

참고