android-testing

Files (1)

• SKILL.md

SKILL.md (first lines)

# Android / KMP Testing
 
## Stack
 
| Concern | Library |
|---|---|
| Test framework | JUnit5 |
| Assertions | AssertK |
| Flow / StateFlow testing | Turbine |
| Coroutine testing | `kotlinx-coroutines-test` + `UnconfinedTestDispatcher` |
| UI testing | `ComposeTestRule` |
 
---
 
## ViewModel Unit Tests
 
### Setup
 
```kotlin
class NoteListViewModelTest {
    private val testDispatcher = UnconfinedTestDispatcher()
 
    @BeforeEach
    fun setUp() {
        Dispatchers.setMain(testDispatcher)
    }
 
    @AfterEach
    fun tearDown() {
        Dispatchers.resetMain()
    }
}
```
 
### Testing State with Turbine
 
```kotlin
@Test
fun `loading notes emits notes in state`() = runTest {
    val repo = FakeNoteRepository()
    val viewModel = NoteListViewModel(repo)
 
    viewModel.state.test {
        viewModel.onAction(NoteListAction.OnRefreshClick)
        assertThat(awaitItem().isLoading).isTrue()
        assertThat(awaitItem().notes).isNotEmpty()
    }
}
```
 
### Testing Events (one-time side effects)
 
```kotlin
@Test
fun `clicking note sends NavigateToDetail event`() = runTest {
    val viewModel = NoteListViewModel(FakeNoteRepository())
 
    viewModel.events.test {
        viewModel.onAction(NoteListAction.OnNoteClick("123"))
        assertThat(awaitItem()).isEqualTo(NoteListEvent.NavigateToDetail("123"))
    }
}
```
 
---
 
## Fake Repositories
 
Prefer **fakes** (not mocks) for repository dependencies. A fake is a simple in-memory implementation:
 
```kotlin
class FakeNoteRepository : NoteRepository {
    private val notes = mutableListOf<Note>()
    var shouldReturnError = false
 
    override suspend fun getNotes(): Result<List<Note>, DataError.Local> {
        return if (shouldReturnError) Result.Error(DataError.Local.UNKNOWN)
        else Result.Success(notes.toList())
    }
 
    override suspend fun insertNote(note: Note): EmptyResult<DataError.Local> {
        notes.add(note)
        return Result.Success(Unit)
    }
}
```
 
---
 
## SavedStateHandle in Tests
 
Instantiate it directly — no mocking needed:
 
```kotlin
val savedStateHandle = SavedStateHandle(mapOf("noteId" to "123"))
val viewModel = NoteEditorViewModel(savedStateHandle, FakeNoteRepository())
```
 
---
 
## When to Inject Dispatchers
 
Only inject `CoroutineDispatcher` into a class when:
1. It dispatches to a non-main dispatcher (e.g., `IO`), AND
2. That class is directly unit-tested.
 
ViewModels that only use `viewModelScope` do not need injected dispatchers. Use `Dispatchers.setMain()` in tests instead.
 
If a non-ViewModel class uses `withContext(Dispatchers.IO)` and is unit-tested, inject the dispatcher:
 
```kotlin
class ImageCompressor(private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO) {
    suspend fun compress(bytes: ByteArray): ByteArray = withContext(ioDispatcher) { ... }
}
 
// In test:
val compressor = ImageCompressor(ioDispatcher = UnconfinedTestDispatcher())
```

From kvithayathil/agent-resources, AGPL-3.0.

More from kvithayathil/agent-resources