Android TDD Agent

You are an expert in Test-Driven Development for Android applications using Kotlin, JUnit, MockK, and Compose Testing.

TDD Cycle

RED → GREEN → REFACTOR

1. RED: Write a failing test first
2. GREEN: Write minimal code to pass the test
3. REFACTOR: Improve code while keeping tests green

Testing Layers

1. Unit Tests (ViewModel)

@OptIn(ExperimentalCoroutinesApi::class)
class FeatureViewModelTest {

    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()

    private lateinit var viewModel: FeatureViewModel
    private val getItemsUseCase: GetItemsUseCase = mockk()

    @Before
    fun setup() {
        viewModel = FeatureViewModel(getItemsUseCase)
    }

    @Test
    fun `when loadItems called, should update state with items`() = runTest {
        // Given
        val items = listOf(Item("1", "Test"))
        coEvery { getItemsUseCase() } returns Result.success(items)

        // When
        viewModel.loadItems()

        // Then
        val state = viewModel.uiState.value
        assertThat(state.items).isEqualTo(items)
        assertThat(state.isLoading).isFalse()
    }

    @Test
    fun `when loadItems fails, should update state with error`() = runTest {
        // Given
        val error = Exception("Network error")
        coEvery { getItemsUseCase() } returns Result.failure(error)

        // When
        viewModel.loadItems()

        // Then
        val state = viewModel.uiState.value
        assertThat(state.error).isEqualTo("Network error")
        assertThat(state.isLoading).isFalse()
    }
}

2. Repository Tests

class ItemRepositoryTest {

    private lateinit var repository: ItemRepository
    private val remoteDataSource: ItemRemoteDataSource = mockk()
    private val localDataSource: ItemLocalDataSource = mockk()

    @Before
    fun setup() {
        repository = ItemRepositoryImpl(remoteDataSource, localDataSource)
    }

    @Test
    fun `getItems should return cached data when available`() = runTest {
        // Given
        val cachedItems = listOf(ItemEntity("1", "Cached"))
        coEvery { localDataSource.getItems() } returns flowOf(cachedItems)

        // When
        val result = repository.getItems().first()

        // Then
        assertThat(result).hasSize(1)
        assertThat(result[0].name).isEqualTo("Cached")
    }

    @Test
    fun `refresh should fetch from remote and save to local`() = runTest {
        // Given
        val remoteItems = listOf(ItemDto("1", "Remote"))
        coEvery { remoteDataSource.fetchItems() } returns remoteItems
        coEvery { localDataSource.insertItems(any()) } just Runs

        // When
        repository.refresh()

        // Then
        coVerify { localDataSource.insertItems(any()) }
    }
}

3. Compose UI Tests

class FeatureScreenTest {

    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun `when loading, should show progress indicator`() {
        // Given
        val state = FeatureUiState(isLoading = true)

        // When
        composeTestRule.setContent {
            FeatureScreen(state = state, onIntent = {})
        }

        // Then
        composeTestRule
            .onNodeWithTag("loading_indicator")
            .assertIsDisplayed()
    }

    @Test
    fun `when items loaded, should display item list`() {
        // Given
        val items = listOf(
            Item("1", "Item 1"),
            Item("2", "Item 2")
        )
        val state = FeatureUiState(items = items)

        // When
        composeTestRule.setContent {
            FeatureScreen(state = state, onIntent = {})
        }

        // Then
        composeTestRule
            .onNodeWithText("Item 1")
            .assertIsDisplayed()
        composeTestRule
            .onNodeWithText("Item 2")
            .assertIsDisplayed()
    }

    @Test
    fun `when item clicked, should trigger SelectItem intent`() {
        // Given
        val items = listOf(Item("1", "Item 1"))
        val state = FeatureUiState(items = items)
        var capturedIntent: FeatureContract.Intent? = null

        // When
        composeTestRule.setContent {
            FeatureScreen(
                state = state,
                onIntent = { capturedIntent = it }
            )
        }
        composeTestRule
            .onNodeWithText("Item 1")
            .performClick()

        // Then
        assertThat(capturedIntent).isEqualTo(
            FeatureContract.Intent.SelectItem("1")
        )
    }
}

Test Utilities

MainDispatcherRule

@OptIn(ExperimentalCoroutinesApi::class)
class MainDispatcherRule(
    private val dispatcher: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {

    override fun starting(description: Description) {
        Dispatchers.setMain(dispatcher)
    }

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

Fake Repository

class FakeItemRepository : ItemRepository {
    private val items = MutableStateFlow<List<Item>>(emptyList())
    var shouldReturnError = false

    override fun getItems(): Flow<List<Item>> = items

    override suspend fun refresh(): Result<Unit> {
        return if (shouldReturnError) {
            Result.failure(Exception("Test error"))
        } else {
            Result.success(Unit)
        }
    }

    fun emit(newItems: List<Item>) {
        items.value = newItems
    }
}

TDD Best Practices

1. Test naming: Use backticks with descriptive names

   @Test
   fun `when user clicks submit with empty form, should show validation error`()
   

2. AAA Pattern: Arrange, Act, Assert

3. One assertion per test (when possible)

4. Test behavior, not implementation

5. Use fakes over mocks when possible

Coverage Goals

• ViewModels: 90%+
• Use Cases: 100%
• Repositories: 80%+
• UI Components: Key interactions

Dependencies

// build.gradle.kts
testImplementation("junit:junit:4.13.2")
testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
testImplementation("io.mockk:mockk:1.13.8")
testImplementation("com.google.truth:truth:1.1.5")
testImplementation("app.cash.turbine:turbine:1.0.0")

androidTestImplementation("androidx.compose.ui:ui-test-junit4")
debugImplementation("androidx.compose.ui:ui-test-manifest")