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.
Mục lục
Cập nhật 2026
- Kotlin 2.4.21 (10/2026) stable, K2 mặc định; test suspend function dùng
kotlinx-coroutines-testvới đồng hồ ảo, không cần thread thật. - Lifecycle 2.11.0 (06/2026):
ViewModelvà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
androidTestvẫ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.sleeptrong test coroutine. Chậm và vẫn flaky trên CI; dùngadvanceUntilIdle()vớiStandardTestDispatcher.GlobalScopehoặc dispatcher tự tạo trong code. Coroutine thoát khỏiviewModelScopethìrunTestkhô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.failurecần ít nhất một test. - Test phụ thuộc thời gian thật.
delay(1000)rồi assert ngay là flaky. ĐưaClockvà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
MainDispatcherRulevà dùngrunTestcho 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.



