Testing Coroutines

1. Giới thiệu

Testing code với coroutines đòi hỏi các tools đặc biệt để:

Kiểm soát thời gian (virtual time)
Test suspend functions
Test Flows
Xử lý concurrent operations

2. Setup

Thêm dependencies trong build.gradle.kts:


dependencies {
    // Coroutines test
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
    
    // Turbine for Flow testing
    testImplementation("app.cash.turbine:turbine:1.0.0")
    
    // JUnit
    testImplementation("junit:junit:4.13.2")
}

3. runTest - Basic Coroutine Testing

runTest là builder chính cho coroutine tests:


import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
 
class RepositoryTest {
    
    @Test
    fun `fetchUser returns correct user`() = runTest {
        val repository = UserRepository()
        
        val user = repository.fetchUser("123")
        
        assertEquals("Alice", user.name)
    }
}
 
class UserRepository {
    suspend fun fetchUser(id: String): User {
        delay(1000)  // Simulated network delay
        return User(id, "Alice")
    }
}
 
data class User(val id: String, val name: String)

runTest tự động skip delays - test chạy ngay lập tức!

4. Virtual Time với TestDispatcher

advanceTimeBy và advanceUntilIdle


import kotlinx.coroutines.test.*
import kotlinx.coroutines.*
 
class TimerTest {
    
    @Test
    fun `timer emits values over time`() = runTest {
        var count = 0
        
        launch {
            repeat(3) {
                delay(1000)
                count++
            }
        }
        
        assertEquals(0, count)
        
        advanceTimeBy(1000)
        assertEquals(1, count)
        
        advanceTimeBy(1000)
        assertEquals(2, count)
        
        advanceUntilIdle()  // Advance đến hết
        assertEquals(3, count)
    }
}

Kiểm soát chính xác timing


class DebounceTest {
    
    @Test
    fun `debounce only emits after delay`() = runTest {
        val results = mutableListOf<String>()
        
        launch {
            debounce(300) { results.add("First") }
        }
        
        // Trước 300ms - chưa emit
        advanceTimeBy(200)
        assertEquals(0, results.size)
        
        // Sau 300ms - emit
        advanceTimeBy(100)
        assertEquals(1, results.size)
        assertEquals("First", results[0])
    }
    
    private suspend fun debounce(delayMs: Long, action: () -> Unit) {
        delay(delayMs)
        action()
    }
}

5. TestDispatcher và Dependency Injection

Inject dispatcher cho testability


// Production code
class DataSyncService(
    private val dispatcher: CoroutineDispatcher = Dispatchers.IO
) {
    suspend fun syncData(): List<String> = withContext(dispatcher) {
        delay(5000)  // Long operation
        listOf("data1", "data2")
    }
}
 
// Test code
class DataSyncServiceTest {
    
    @Test
    fun `syncData returns data`() = runTest {
        val testDispatcher = StandardTestDispatcher(testScheduler)
        val service = DataSyncService(testDispatcher)
        
        val deferred = async { service.syncData() }
        
        advanceUntilIdle()
        
        assertEquals(listOf("data1", "data2"), deferred.await())
    }
}

UnconfinedTestDispatcher vs StandardTestDispatcher


@Test
fun `immediate execution with UnconfinedTestDispatcher`() = runTest {
    val unconfinedDispatcher = UnconfinedTestDispatcher(testScheduler)
    
    var executed = false
    
    launch(unconfinedDispatcher) {
        executed = true
    }
    
    // Với Unconfined, đã execute ngay
    assertTrue(executed)
}
 
@Test
fun `controlled execution with StandardTestDispatcher`() = runTest {
    val standardDispatcher = StandardTestDispatcher(testScheduler)
    
    var executed = false
    
    launch(standardDispatcher) {
        executed = true
    }
    
    // Với Standard, chưa execute
    assertFalse(executed)
    
    advanceUntilIdle()
    assertTrue(executed)
}

6. Testing Flows với Turbine

Turbine là library phổ biến nhất để test Flows:

Basic Flow testing


import app.cash.turbine.test
import kotlinx.coroutines.flow.*
 
class FlowTest {
    
    @Test
    fun `flow emits expected values`() = runTest {
        flow {
            emit(1)
            emit(2)
            emit(3)
        }.test {
            assertEquals(1, awaitItem())
            assertEquals(2, awaitItem())
            assertEquals(3, awaitItem())
            awaitComplete()
        }
    }
}

Testing StateFlow


class CounterViewModel {
    private val _count = MutableStateFlow(0)
    val count: StateFlow<Int> = _count.asStateFlow()
    
    fun increment() {
        _count.value++
    }
}
 
class CounterViewModelTest {
    
    @Test
    fun `increment increases count`() = runTest {
        val viewModel = CounterViewModel()
        
        viewModel.count.test {
            assertEquals(0, awaitItem())  // Initial value
            
            viewModel.increment()
            assertEquals(1, awaitItem())
            
            viewModel.increment()
            assertEquals(2, awaitItem())
            
            cancelAndIgnoreRemainingEvents()
        }
    }
}

Testing SharedFlow (events)


sealed class UiEvent {
    data class ShowToast(val message: String) : UiEvent()
    object NavigateBack : UiEvent()
}
 
class EventViewModel {
    private val _events = MutableSharedFlow<UiEvent>()
    val events: SharedFlow<UiEvent> = _events.asSharedFlow()
    
    suspend fun showToast(message: String) {
        _events.emit(UiEvent.ShowToast(message))
    }
}
 
class EventViewModelTest {
    
    @Test
    fun `showToast emits event`() = runTest {
        val viewModel = EventViewModel()
        
        viewModel.events.test {
            viewModel.showToast("Hello")
            
            val event = awaitItem()
            assertTrue(event is UiEvent.ShowToast)
            assertEquals("Hello", (event as UiEvent.ShowToast).message)
            
            cancelAndIgnoreRemainingEvents()
        }
    }
}

Testing Flow với delay


fun tickerFlow(intervalMs: Long): Flow<Int> = flow {
    var count = 0
    while (true) {
        emit(count++)
        delay(intervalMs)
    }
}
 
class TickerFlowTest {
    
    @Test
    fun `ticker emits at intervals`() = runTest {
        tickerFlow(1000).test {
            assertEquals(0, awaitItem())
            
            advanceTimeBy(1000)
            assertEquals(1, awaitItem())
            
            advanceTimeBy(1000)
            assertEquals(2, awaitItem())
            
            cancelAndIgnoreRemainingEvents()
        }
    }
}

7. Testing Error Handling

Testing exceptions


class ErrorHandlingTest {
    
    @Test
    fun `flow catches errors`() = runTest {
        flow {
            emit(1)
            throw RuntimeException("Error!")
        }
        .catch { emit(-1) }
        .test {
            assertEquals(1, awaitItem())
            assertEquals(-1, awaitItem())
            awaitComplete()
        }
    }
    
    @Test
    fun `flow propagates uncaught errors`() = runTest {
        flow<Int> {
            throw RuntimeException("Error!")
        }.test {
            val error = awaitError()
            assertEquals("Error!", error.message)
        }
    }
}

Testing retry logic


class RetryTest {
    
    @Test
    fun `retry succeeds after failures`() = runTest {
        var attempts = 0
        
        flow {
            attempts++
            if (attempts < 3) {
                throw RuntimeException("Attempt $attempts failed")
            }
            emit("Success")
        }
        .retry(3) { true }
        .test {
            assertEquals("Success", awaitItem())
            awaitComplete()
        }
        
        assertEquals(3, attempts)
    }
}

8. Testing ViewModels

Complete ViewModel test


class UserViewModel(
    private val repository: UserRepository,
    private val dispatcher: CoroutineDispatcher = Dispatchers.Main
) : ViewModel() {
    
    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()
    
    fun loadUser(userId: String) {
        viewModelScope.launch(dispatcher) {
            _uiState.value = UiState.Loading
            try {
                val user = repository.getUser(userId)
                _uiState.value = UiState.Success(user)
            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Unknown error")
            }
        }
    }
}
 
sealed class UiState {
    object Loading : UiState()
    data class Success(val user: User) : UiState()
    data class Error(val message: String) : UiState()
}
 
class UserViewModelTest {
    
    @Test
    fun `loadUser success updates state`() = runTest {
        val fakeRepository = FakeUserRepository()
        val viewModel = UserViewModel(
            repository = fakeRepository,
            dispatcher = StandardTestDispatcher(testScheduler)
        )
        
        viewModel.uiState.test {
            assertEquals(UiState.Loading, awaitItem())
            
            viewModel.loadUser("123")
            advanceUntilIdle()
            
            val state = awaitItem()
            assertTrue(state is UiState.Success)
            assertEquals("Alice", (state as UiState.Success).user.name)
            
            cancelAndIgnoreRemainingEvents()
        }
    }
    
    @Test
    fun `loadUser error updates state`() = runTest {
        val fakeRepository = FakeUserRepository(shouldFail = true)
        val viewModel = UserViewModel(
            repository = fakeRepository,
            dispatcher = StandardTestDispatcher(testScheduler)
        )
        
        viewModel.uiState.test {
            skipItems(1)  // Skip initial Loading
            
            viewModel.loadUser("123")
            advanceUntilIdle()
            
            val state = awaitItem()
            assertTrue(state is UiState.Error)
            
            cancelAndIgnoreRemainingEvents()
        }
    }
}
 
class FakeUserRepository(private val shouldFail: Boolean = false) : UserRepository {
    override suspend fun getUser(id: String): User {
        if (shouldFail) throw RuntimeException("Network error")
        return User(id, "Alice")
    }
}

9. Testing Timeouts


class TimeoutTest {
    
    @Test
    fun `operation completes within timeout`() = runTest {
        val result = withTimeout(1000) {
            delay(500)
            "Success"
        }
        
        assertEquals("Success", result)
    }
    
    @Test
    fun `operation timeout returns null`() = runTest {
        val result = withTimeoutOrNull(500) {
            delay(1000)
            "Never returned"
        }
        
        assertNull(result)
    }
}

10. Best Practices


// ✅ Inject dispatchers
class MyRepository(
    private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO
)
 
// ✅ Use runTest for all coroutine tests
@Test
fun myTest() = runTest { }
 
// ✅ Use Turbine for Flow testing
flow.test {
    assertEquals(expected, awaitItem())
}
 
// ✅ Use TestDispatcher for controlled execution
val testDispatcher = StandardTestDispatcher(testScheduler)
 
// ✅ Clean up with cancelAndIgnoreRemainingEvents()
flow.test {
    // assertions
    cancelAndIgnoreRemainingEvents()
}
 
// ❌ Don't use runBlocking in tests
// @Test fun badTest() = runBlocking { }  // BAD
 
// ❌ Don't use real delays in tests
// delay(5000)  // Makes tests slow

📝 Tóm tắt

Tool	Purpose
`runTest`	Test builder với virtual time
`advanceTimeBy()`	Skip time forward
`advanceUntilIdle()`	Run all pending coroutines
`StandardTestDispatcher`	Controlled execution
`UnconfinedTestDispatcher`	Immediate execution
`Turbine.test {}`	Flow testing
`awaitItem()`	Get next Flow emission
`awaitComplete()`	Assert Flow completes
`awaitError()`	Assert Flow errors

Key points:

Inject dispatchers để dễ test
runTest tự động skip delays
Turbine là cách tốt nhất để test Flows
Dùng StandardTestDispatcher cho controlled timing