Android Developer Roadmap: Kiểm thử Đơn vị trong Android với JUnit – Tăng cường Độ tin cậy Mã nguồn của Bạn

Một ViewModel 400 dòng vẫn trả đúng danh sách sau khi bạn sửa điều kiện lọc, cho đến khi người dùng bấm sang tab khác và thấy màn hình trắng. Kiểm thử đơn vị không phải thủ tục để đạt con số coverage: nó là hợp đồng hành vi bạn viết một lần, máy kiểm tra lại mỗi lần build. Dưới đây là JUnit 4 và Jupiter, assertion, test double, coroutine, Flow, và hai bài test dùng được ngay cho ViewModel và repository.

Cập nhật 2026

  • Kotlin 2.4.21 (10/2026) stable, K2 mặc định; test suspend function dùng kotlinx-coroutines-test với đồng hồ ảo, không cần thread thật.
  • Lifecycle 2.11.0 (06/2026): ViewModel và viewModelScope ổn định, test ViewModel không cần Activity hay Espresso.
  • Template Android Studio vẫn sinh JUnit 4; Jupiter dùng được cho local test, còn androidTest vẫn chạy JUnit 4 vì runner AndroidX dựa trên nó. Build dùng JDK 17 (baseline AGP 9.5).

Đơn vị là hành vi, không phải file

Unit test kiểm tra một hành vi quan sát được, với mọi thứ bên ngoài được thay bằng đối tượng bạn kiểm soát. Đơn vị không nhất thiết là một class: nó có thể là một mapper, một use case, một nhánh xử lý lỗi trong ViewModel. Điều quyết định là test phải quan sát được kết quả — state, giá trị trả về, phần tử phát ra — chứ không đọc code bên trong để đoán.

Giá trị tập trung ở tầng logic: ViewModel, repository, use case, mapper. Đừng unit test Activity bằng JUnit thuần; đó là việc của Robolectric hoặc instrumented test.

Tiêu chí test/ (JVM) androidTest/ (thiết bị)
Tốc độ Vài giây cho cả bộ Phút, cần thiết bị hoặc giả lập
Android API Không có; chỉ Robolectric mô phỏng Framework thật, Context thật
Dùng cho ViewModel, repository, mapper, use case Espresso, quyền, notification, DB thật

JUnit 4 hay JUnit 5 (Jupiter)?

JUnit 5 không phải một artifact mà là ba thứ: Platform (bộ chạy), Jupiter (API viết test) và Vintage (cầu nối chạy test JUnit 4 cũ). Vì vậy câu hỏi đúng là: bạn dùng API nào, và bộ chạy nào đang được gọi.

Hai API khác nhau ở tên annotation và vài tiện ích: Jupiter có parameterized test và @Nested ngay trong core, JUnit 4 cần @RunWith(Parameterized::class). Muốn viết local test bằng Jupiter, bạn phải cấu hình task test dùng JUnit Platform — testOptions.unitTests.all { it.useJUnitPlatform() } trong app/build.gradle.kts — và thêm Jupiter cùng junit-platform-launcher; version để trong version catalog.

JUnit 4 JUnit 5 (Jupiter) Ghi chú
@Before / @After @BeforeEach / @AfterEach Chạy quanh mỗi test
@BeforeClass / @AfterClass @BeforeAll / @AfterAll Một lần cho cả class, phải static
@Rule @ExtendWith Không có lớp tương đương 1-1

Giữ JUnit 4 cho androidTest vì không có lựa chọn; với local test, chọn một API và dùng nhất quán. Đừng trộn hai API trong cùng module.

Assertion: JUnit đủ dùng, Truth và AssertJ chỉ đổi cách đọc

assertEquals(expected, actual) của JUnit 4 nhận tham số ngược với thói quen viết văn xuôi, và khi fail chỉ báo “expected 5 but was 3” — đủ nhưng nghèo ngữ cảnh. Truth và AssertJ viết theo kiểu assertThat(actual) rồi mô tả kỳ vọng, nên khó hoán đổi vị trí và thông báo dễ đọc hơn với collection.

assertEquals("Sai tổng", 5, calculator.add(3, 2))   // JUnit 4: message, expected, actual
assertThat(calculator.add(3, 2)).isEqualTo(5)      // Truth hoặc AssertJ

Cả ba đều đủ cho unit test; chọn theo team. Bài này không pin version vì các thư viện assertion phát hành thường xuyên. Với Kotlin, kotlin.test cho assertEquals, assertTrue, assertFailsWith<IOException> chạy được cả trên JVM và multiplatform.

Test double: fake trước, mock sau

Ba loại hay bị gọi lẫn thành “mock”. Phân biệt để chọn đúng:

Loại Là gì Dùng khi
Stub Trả dữ liệu cố định, không kiểm tra lời gọi Cần đầu vào cho một nhánh cụ thể
Fake Cài đặt thật nhưng nhẹ, thường in-memory Repository, DAO, API client — mặc định
Mock Đối tượng thay thế có ghi nhận lời gọi Xác minh tương tác với thứ ngoài tầm kiểm soát

Fake là mặc định cho repository và data source: chạy nhanh, không cần MockK hiểu generic, không phải viết every { } cho từng lời gọi. MockK phù hợp với class final và suspend function nhờ coEvery, coVerify; Mockito thường đi kèm mockito-kotlin để viết whenever, verify tự nhiên hơn. Chỉ mock biên giới bên ngoài — analytics, logger, clock — khi cần khẳng định “gọi đúng một lần”: verify(exactly = 1) { analytics.log("order_created") }.

Coroutine: runTest và đồng hồ ảo

runTest thay runBlocking: bỏ qua delay thật, báo lỗi nếu coroutine còn sống khi test kết thúc, và dùng StandardTestDispatcher mặc định. Với dispatcher chuẩn, coroutine không chạy ngay khi launch — bạn phải gọi advanceUntilIdle() hoặc runCurrent().

// File: app/src/test/java/com/evotek/testing/MainDispatcherRule.kt
@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()
}

Rule này thay Dispatchers.Main bằng dispatcher test trước mỗi test và trả lại sau đó, nên viewModelScope chạy trên đồng hồ ảo. runTest lấy scheduler từ dispatcher đang gắn vào Main, nên advanceUntilIdle() điều khiển được coroutine trong ViewModel. Nếu bạn tự tạo dispatcher trong từng test, truyền scheduler của nó vào runTest để hai bên dùng chung một đồng hồ.

Ví dụ chạy được: test ViewModel với fake repository

ViewModel tập trung quyết định trạng thái nên là test đáng viết nhất. Giả định bạn đã có Order và OrdersUiState:

// File: app/src/main/java/com/evotek/orders/OrdersRepository.kt
interface OrdersRepository {
    suspend fun loadOrders(): Result<List<Order>>
}

// File: app/src/main/java/com/evotek/orders/OrdersViewModel.kt
class OrdersViewModel(
    private val repository: OrdersRepository,
) : ViewModel() {

    private val _state = MutableStateFlow(OrdersUiState())
    val state: StateFlow<OrdersUiState> = _state.asStateFlow()

    fun refresh() {
        viewModelScope.launch {
            _state.update { it.copy(isLoading = true, error = null) }
            repository.loadOrders()
                .onSuccess { orders -> _state.update { it.copy(isLoading = false, orders = orders) } }
                .onFailure { error -> _state.update { it.copy(isLoading = false, error = error.message) } }
        }
    }
}

Fake repository chỉ cần dữ liệu trả về và độ trễ tùy chọn để test trạng thái loading:

// File: app/src/test/java/com/evotek/orders/FakeOrdersRepository.kt
class FakeOrdersRepository(
    var response: Result<List<Order>> = Result.success(emptyList()),
    private val latencyMillis: Long = 0,
) : OrdersRepository {
    override suspend fun loadOrders(): Result<List<Order>> {
        if (latencyMillis > 0) delay(latencyMillis)
        return response
    }
}
// File: app/src/test/java/com/evotek/orders/OrdersViewModelTest.kt
class OrdersViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private val repository = FakeOrdersRepository()
    private val viewModel = OrdersViewModel(repository)

    @Test
    fun `tải thành công thì state có dữ liệu và tắt loading`() = runTest {
        repository.response = Result.success(listOf(Order(1, "Trà đào", 30_000)))

        viewModel.refresh()
        advanceUntilIdle()

        val state = viewModel.state.value
        assertFalse(state.isLoading)
        assertEquals(1, state.orders.size)
        assertNull(state.error)
    }

    @Test
    fun `tải lỗi thì tắt loading và giữ thông báo`() = runTest {
        repository.response = Result.failure(IOException("hết thời gian chờ"))

        viewModel.refresh()
        advanceUntilIdle()

        val state = viewModel.state.value
        assertFalse(state.isLoading)
        assertEquals("hết thời gian chờ", state.error)
    }
}

Hai test, hai hành vi, cùng một fake. Không Thread.sleep, không runBlocking, không phụ thuộc máy hay mạng. Nếu ViewModel đọc SavedStateHandle, tạo nó bằng SavedStateHandle(mapOf("orderId" to 7L)) thay vì qua Activity.

Ví dụ chạy được: test repository với fake data source

Repository đáng test ở ba điểm: mapping, ghi cache và nhánh lỗi. Fake API và fake DAO cho phép tạo cả ba mà không cần MockWebServer hay database thật.

// File: app/src/main/java/com/evotek/orders/OrdersRepositoryImpl.kt
class OrdersRepositoryImpl(
    private val api: OrdersApi,
    private val dao: OrdersDao,
) : OrdersRepository {

    override suspend fun loadOrders(): Result<List<Order>> =
        try {
            val remote = api.fetchOrders()
            dao.replaceAll(remote.map { OrderEntity(it.id, it.title, it.amount) })
            Result.success(remote.map { Order(it.id, it.title, it.amount) })
        } catch (e: IOException) {
            val cached = dao.getAll().map { Order(it.id, it.name, it.price) }
            if (cached.isEmpty()) Result.failure(e) else Result.success(cached)
        }
}

Chú ý catch (e: IOException) chứ không phải Throwable: bắt hẹp để CancellationException vẫn lan ra ngoài và structured concurrency không bị phá. Đây cũng là lý do không nên dùng runCatching bừa bãi trong code production lẫn trong test.

// File: app/src/test/java/com/evotek/data/Fakes.kt
class FakeOrdersApi : OrdersApi {
    var response: List<OrderDto> = emptyList()
    var error: Throwable? = null

    override suspend fun fetchOrders(): List<OrderDto> {
        error?.let { throw it }
        return response
    }
}

class FakeOrdersDao : OrdersDao {
    val stored = MutableStateFlow<List<OrderEntity>>(emptyList())

    override fun observeAll(): Flow<List<OrderEntity>> = stored
    override suspend fun getAll(): List<OrderEntity> = stored.value
    override suspend fun replaceAll(items: List<OrderEntity>) {
        stored.value = items
    }
}
// File: app/src/test/java/com/evotek/orders/OrdersRepositoryImplTest.kt
class OrdersRepositoryImplTest {

    private val api = FakeOrdersApi()
    private val dao = FakeOrdersDao()
    private val repository = OrdersRepositoryImpl(api, dao)

    @Test
    fun `khi api trả dữ liệu thì map sang domain và ghi cache`() = runTest {
        api.response = listOf(OrderDto(id = 7, title = "Bánh mì", amount = 20_000))

        val result = repository.loadOrders()

        assertEquals("Bánh mì", result.getOrThrow().single().name)
        assertEquals(1, dao.stored.value.size)
    }

    @Test
    fun `khi api lỗi và có cache thì trả cache`() = runTest {
        api.error = IOException("mất mạng")
        dao.replaceAll(listOf(OrderEntity(9, "Cà phê", 25_000)))

        val result = repository.loadOrders()

        assertTrue(result.isSuccess)
        assertEquals("Cà phê", result.getOrThrow().single().name)
    }

    @Test
    fun `khi api lỗi và cache rỗng thì trả failure`() = runTest {
        api.error = IOException("mất mạng")

        val result = repository.loadOrders()

        assertTrue(result.isFailure)
        assertTrue(result.exceptionOrNull() is IOException)
    }
}

Test thứ ba là nhánh lỗi — thứ hầu hết repo Android thiếu, nên màn hình lỗi hiếm khi được kiểm tra.

Kiểm thử Flow: Turbine hoặc tự thu thập

Flow không có “kết quả cuối” để assert; bạn kiểm tra chuỗi giá trị phát ra. Turbine biến việc đó thành awaitItem(), awaitComplete() và tự hủy collection khi test xong — với StateFlow, kết thúc bằng cancelAndIgnoreRemainingEvents() vì flow không bao giờ complete.

// File: app/src/test/java/com/evotek/data/OrdersDaoTest.kt
@Test
fun `observeAll phát danh sách mới sau khi ghi cache`() = runTest {
    val dao = FakeOrdersDao()
    dao.observeAll().test {
        assertEquals(emptyList(), awaitItem())
        dao.replaceAll(listOf(OrderEntity(9, "Cà phê", 25_000)))
        assertEquals(1, awaitItem().size)
        cancelAndIgnoreRemainingEvents()
    }
}

Không có Turbine, bạn dùng backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) { flow.toList(emissions) } rồi assert sau advanceUntilIdle(). backgroundScope tự hủy khi test kết thúc nên không treo runTest, nhưng cách này dễ sai thứ tự và khó đọc.

Đặt tên và cấu trúc: Given–When–Then

Tên test là một câu khẳng định về hành vi, không phải tên hàm. Với local test trên JVM, backtick cho phép dấu cách và tiếng Việt: fun `khi token hết hạn thì state chuyển sang đăng xuất`(). Trong androidTest, dùng tên không dấu cách.

Thân test chia ba khối cách nhau bằng dòng trống: Given dựng state và fake, When gọi một hành vi, Then assert. Thấy chữ “và” trong tên test thì tách. Không viết vòng lặp hay if trong test.

Robolectric: khi code cần Context nhưng không cần thiết bị

Robolectric chạy Android framework trên JVM, đủ cho Context.getString, Resources, Looper và SharedPreferences. Bật testOptions.unitTests.isIncludeAndroidResources = true, chạy với @RunWith(RobolectricTestRunner::class), chọn SDK bằng @Config(sdk = [36]) — nhưng kiểm tra bảng SDK mà bản Robolectric bạn dùng hỗ trợ, không phải API level nào cũng có shadow.

Nó chậm hơn JUnit thuần và nhanh hơn giả lập, nhưng mô phỏng framework chứ không phải thiết bị: không native lib thật, không hành vi hệ thống thật, không thay instrumented test cho quyền hay notification. Dùng cho unit test có Context, đừng dùng để “chạy Espresso cho nhanh”.

Coverage: con số không phải mục tiêu

JaCoCo và Kover đo dòng lệnh và nhánh đã chạy, không đo hành vi đã đúng. Một hàm 100% line coverage vẫn có thể trả sai ở nhánh biên. Code sinh tự động — Hilt, Room, Compose compiler — làm mẫu số phình ra và kéo con số xuống mà không phản ánh chất lượng test.

Cách dùng hợp lý: exclude package generated, đặt ngưỡng cho code mới trong PR thay vì toàn repo cũ, và đọc danh sách nhánh chưa chạy thay vì nhìn phần trăm. Viết test chỉ để tăng số là cách nhanh nhất để có bộ test chậm, giòn và không bắt được lỗi.

Bảy bẫy thường gặp

  • Test framework thay vì hành vi. Assert repository.loadOrders() được gọi nhưng không assert state sau đó; đổi thứ tự gọi là test đỏ dù hành vi vẫn đúng.
  • Thread.sleep trong test coroutine. Chậm và vẫn flaky trên CI; dùng advanceUntilIdle() với StandardTestDispatcher.
  • GlobalScope hoặc dispatcher tự tạo trong code. Coroutine thoát khỏi viewModelScope thì runTest không kiểm soát được và test treo. Inject dispatcher.
  • Mock mọi thứ. Mock repository, mapper, DAO khiến test chỉ kiểm tra dây nối. Fake cho hạ tầng, mock chỉ cho thứ không fake được.
  • Không test nhánh lỗi. Lỗi mạng, cache rỗng, JSON hỏng mới là nơi bug sống. Mỗi Result.failure cần ít nhất một test.
  • Test phụ thuộc thời gian thật. delay(1000) rồi assert ngay là flaky. Đưa Clock vào và dùng thời gian ảo.
  • Test private method. Phải reflection để chạm hàm private nghĩa là hành vi đó nên đưa ra public hoặc tách class nhỏ hơn.

Nhìn tới 2027

Kotlin 2.5.0 dự kiến ra tháng 12/2026; API test coroutine không đổi lớn, nhưng với Kotlin Multiplatform, logic dùng chung sẽ chuyển dần sang commonTest với kotlin.test. JUnit 4 vẫn là thứ androidTest phải dùng, còn local test chạm nhiều Android code hơn nhờ Robolectric.

Checklist

  • Chọn một API JUnit cho local test; version trong version catalog.
  • Thêm MainDispatcherRule và dùng runTest cho mọi test có suspend function.
  • Viết fake repository/DAO trước; chỉ mock biên giới bên ngoài.
  • Mỗi ViewModel có test thành công và test lỗi; mỗi repository có test mapping, cache, failure.
  • Đặt tên theo hành vi, cấu trúc Given–When–Then.
  • Coverage exclude code sinh tự động; ngưỡng chỉ áp cho code mới.

Bước tiếp theo là kiểm thử UI với Espresso. Nếu ViewModel chưa tách khỏi UI, đọc lại lựa chọn kiến trúc MVVM/MVI và Flow trong lập trình phản ứng. Toàn bộ thứ tự bài học nằm ở Android Developer Roadmap.