Compose Testing

Compose Test Setup

Compose UI testing uses a different framework than Espresso. It operates on the semantics tree instead of the view hierarchy.

Dependencies

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

The test manifest provides the Compose activity that hosts your composables during tests. Without it, tests crash with a missing activity error.

ComposeTestRule

createComposeRule() is the entry point for all Compose tests:

@RunWith(AndroidJUnit4::class)
class ProductCardTest {

    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun productCard_displaysNameAndPrice() {
        composeTestRule.setContent {
            MaterialTheme {
                ProductCard(
                    product = Product(
                        id = "1",
                        name = "Widget",
                        price = 9.99
                    )
                )
            }
        }

        composeTestRule.onNodeWithText("Widget").assertIsDisplayed()
        composeTestRule.onNodeWithText("$9.99").assertIsDisplayed()
    }
}

setContent renders your composable inside the test activity. All onNode calls happen after this.

Testing a Full Activity

If you need to test a composable within its actual Activity (for lifecycle, navigation, etc.), use ActivityScenarioRule:

@get:Rule
val activityRule = ActivityScenarioRule(ProductActivity::class.java)

This launches the real Activity. Use createComposeRule() when you only need to test an isolated composable.

Testing Coroutine Launched Effects

If your composable launches coroutines, use MainDispatcherRule or runTest:

@get:Rule
val mainDispatcherRule = MainDispatcherRule()

@Test
fun loadingIndicator_shownWhileFetching() = composeTestRule.runTest {
    setContent { LoadingScreen(isLoading = true) }
    onNodeWithTag("loading_indicator").assertIsDisplayed()
}

Finding and Matching Nodes

Compose tests find UI elements through the semantics tree. Every composable exposes semantic properties that tests can query.

Finding by Text

// Exact text match
composeTestRule.onNodeWithText("Submit")

// Partial text match
composeTestRule.onNodeWithSubstring("Submit")

// Text with ignore case
composeTestRule.onNodeWithText("submit", ignoreCase = true)

Finding by Test Tag

Test tags are the most reliable way to find composables. Add them in production code:

// In your composable
Button(
    modifier = Modifier.testTag("login_button"),
    onClick = { /* ... */ }
) {
    Text("Login")
}

// In your test
composeTestRule.onNodeWithTag("login_button")

Finding by Content Description

composeTestRule.onNodeWithContentDescription("Close dialog")

Finding by Semantics Properties

// Find by role
composeTestRule.onNode(hasText("Email") and hasClickAction())

// Find by semantics
composeTestRule.onNode(
    hasSemantics {
        isEditable = true
    }
)

Filtering and Combining

// First match only
composeTestRule.onAllNodesWithText("Item").onFirst()

// Last match
composeTestRule.onAllNodesWithText("Item").onLast()

// At index
composeTestRule.onAllNodesWithText("Item").fetchSemanticsNodes().size // count

Unmatched Node Errors

When a node is not found, Espresso gives a clear error:

No node found that matches: hasText("Nonexistent")

This means the composable did not render the expected text. Common causes:

• Wrong text in the composable
• Conditional rendering hiding the element
• Navigation not reaching the expected screen

Actions

Actions interact with composable nodes:

// Click
composeTestRule.onNodeWithTag("submit").performClick()

// Text input
composeTestRule.onNodeWithTag("email_input")
    .performTextInput("test@example.com")

// Replace text
composeTestRule.onNodeWithTag("search")
    .performTextReplacement("new query")

// Scroll
composeTestRule.onNodeWithTag("list")
    .performScrollToIndex(5)

// Touch actions
composeTestRule.onNodeWithTag("image")
    .performTouchInput {
        swipeUp()
    }

// Key events
composeTestRule.onNodeWithTag("field")
    .performKeyInput {
        key Press(KeyEvent.KEYCODE_ENTER)
    }

Assertions

Assertions verify composable state:

// Displayed / Not displayed
composeTestRule.onNodeWithTag("loading").assertIsDisplayed()
composeTestRule.onNodeWithTag("error").assertDoesNotExist()

// Text content
composeTestRule.onNodeWithTag("title")
    .assertTextEquals("Product Details")

// Partial text
composeTestRule.onNodeWithTag("description")
    .assertTextContains("premium")

// Enabled / Disabled
composeTestRule.onNodeWithTag("submit").assertIsEnabled()
composeTestRule.onNodeWithTag("disabled_btn").assertIsNotEnabled()

// Selected
composeTestRule.onNodeWithTag("tab_active").assertIsSelected()

// Clickable
composeTestRule.onNodeWithTag("link").assertHasClickAction()

Waiting for Async Content

Compose tests wait for composition to settle, but for async data loading use waitUntil:

composeTestRule.waitUntil(timeoutMillis = 5000) {
    composeTestRule
        .onAllNodesWithTag("product_item")
        .fetchSemanticsNodes().isNotEmpty()
}

Testing Navigation

Use NavHostController test doubles to verify navigation:

@Test
fun loginButton_navigatesToHome() {
    val navController = rememberNavController()

    composeTestRule.setContent {
        NavHost(navController, startDestination = "login") {
            composable("login") { LoginScreen(onLoginSuccess = { navController.navigate("home") }) }
            composable("home") { HomeScreen() }
        }
    }

    composeTestRule.onNodeWithTag("login_button").performClick()

    composeTestRule.waitUntil(timeoutMillis = 3000) {
        navController.currentDestination?.route == "home"
    }
}