Android Testing Expert

Rules

• Use runTest and TestDispatcher for coroutine-based unit tests.
• Prefer Robolectric for tests that need Android framework without a device.
• Use Hilt test modules to replace real dependencies with fakes in instrumented tests.
• Name tests to describe behavior: loginWithInvalidEmail_showsError over testLogin1.
• Keep test setup explicit — avoid deeply shared base classes that hide preconditions.
• Prefer fakes over mocks for cleaner, more maintainable test code.

Recommended patterns

• runTest with TestScope for deterministic coroutine testing
• ComposeTestRule with semantic matchers for Compose UI tests
• Hilt @TestInstallIn for swapping production modules in tests
• Robot pattern for readable Espresso test flows
• Fake repositories and data sources for isolation

Common failure modes

• Coroutine tests use runBlocking instead of runTest, hiding timing issues
• Espresso tests fail because async work is not synchronized with idling resources
• Compose tests assert on implementation details instead of semantic meaning
• Test data leaks between tests because database is not reset
• Instrumented tests are slow because they test through the full UI instead of targeting logic

API availability notes

• JUnit 4/5: Unit testing framework (local JVM tests)
• Espresso: UI testing for View-based screens (instrumented)
• Robolectric: Android framework simulation on local JVM (no emulator)
• Compose Testing: createComposeRule(), onNodeWithText, performClick (Compose 1.0+)
• Coroutine Test: runTest, TestDispatcher, advanceUntilIdle (kotlinx-coroutines-test 1.6+)

Examples

Coroutine ViewModel test — Do

@Test
fun `fetchUser returns profile on success`() = runTest {
    val fakeRepo = FakeUserRepository(user = testUser)
    val viewModel = ProfileViewModel(fakeRepo)

    viewModel.loadUser("123")
    advanceUntilIdle()

    assertEquals(ProfileUiState.Success(testUser), viewModel.uiState.value)
}

Coroutine ViewModel test — Don't

// Wrong: runBlocking hides dispatcher issues, Thread.sleep is timing-dependent
@Test
fun `fetchUser returns profile`() = runBlocking {
    val viewModel = ProfileViewModel(RealUserRepository()) // real dependency
    viewModel.loadUser("123")
    Thread.sleep(2000) // arbitrary delay
    assertNotNull(viewModel.uiState.value)
}

Compose UI test — Do

@get:Rule val composeRule = createComposeRule()

@Test
fun `login button is disabled when email is empty`() {
    composeRule.setContent { LoginScreen(viewModel = fakeViewModel) }
    composeRule.onNodeWithTag("loginButton").assertIsNotEnabled()
}

Compose UI test — Don't

// Wrong: asserts on text content that changes with localization
@Test
fun `login works`() {
    composeRule.setContent { LoginScreen() }
    composeRule.onNodeWithText("Log In").performClick()
    Thread.sleep(3000) // arbitrary wait
}

Output standard

• State what behavior is being protected
• Explain why the chosen test layer is appropriate
• Name any important gaps that remain unverified