Back in 2026, Sarah, the lead Android dev at “Connect & Create,” had a huge problem: her UI test suite was constantly on fire. Their app, a social media platform built entirely with Jetpack Compose, was picking up users, but every new feature seemed to ship with a new batch of UI bugs their old tests couldn’t catch. The team was burning nearly 40% of every sprint on regression testing and just manually poking at the UI, which was completely unsustainable given their growth plans. They needed to build a resilient, efficient UI testing framework for their Android testing that could actually keep up with Compose’s declarative model.
Key Takeaways
- Use Compose Test Rules to test UI components in a controlled, isolated way.
- Interact with the semantics tree to make your tests stable and not dependent on fragile view hierarchies.
- Use test tagging with
Modifier.testTag()to give UI elements a solid ID that won’t break. - Add screenshot testing to your CI/CD pipeline to automatically catch visual bugs.
Compose’s Declarative Model and Test Fragility
When Connect & Create first jumped on Jetpack Compose, the team was pumped. Google’s declarative UI toolkit promised we’d all build UIs faster and more intuitively. The problem was their old Espresso-based tests, which were built for the XML view system, just couldn’t keep up. As Sarah put it, “We were trying to fit a square peg into a round hole.” Their tests were incredibly fragile, shattering with the smallest UI tweaks, and finding the root cause was like an archaeological dig through layers of nested composables.
The whole model is different, you can’t just use the old view-based matchers that look for resource IDs or specific view types, because that’s not how Compose works. Instead of a fixed, mutable view hierarchy that you can traverse, a Compose UI just renders based on its current state. That dynamic approach is great for development, but it’s exactly what makes writing stable, long-lasting tests so difficult.
Understanding the Compose Testing Toolkit
Google provides a whole testing framework for this, built around the androidx.compose.ui.test library, and that’s where Connect & Create had to focus. At its heart is the ComposeTestRule. Think of it as the engine for any real UI test, giving you the context to actually launch a composable, mess with the clock, and poke at the UI. If you’re not using it, you’re just firing into the dark at a UI that isn’t even properly on screen or under your control.
One of the first problems Sarah’s team hit was internal pushback. Some of the devs kept asking, “it’s just UI, why can’t we use our old tools?” That thinking misses the whole point of the architectural shift. The power of Compose testing is that it works with the semantics tree, a description of the UI’s meaning and accessibility info, not its pixel-perfect layout. This semantic approach makes tests survive visual refactors.
Compose Test Rules and Semantics
The first real change at Connect & Create was making createComposeRule() or createAndroidComposeRule() the standard for every single UI test. You really need the `createAndroidComposeRule` version anytime your composable touches Android-specific stuff like activities or resources. Sarah made it a rule: all new UI tests had to start with a proper setup using one of these.
Take a simple profile screen in their app. The old way to test it might have been to look for a “Follow” button by its text, but what happens when marketing decides that text should be “Add Friend”? Instead, they began using semantics matchers. A test to find that button might look like composeTestRule.onNodeWithText("Follow"). That’s better, but it’s still not perfect, since other things on the screen could also have that same text.
The real breakthrough came from using test tags. With Modifier.testTag(), you can slap a unique, test-only ID onto any composable. So that follow button gets tagged with Modifier.testTag("follow_button"), and the test just looks for it with composeTestRule.onNodeWithTag("follow_button"). This creates a stable contract between the UI and the test that survives design changes. That one change was huge. According to their internal metrics, it cut test failures by 25% in the first month.
Sarah’s team kept running into a common trap: their tests would try to perform an action before the UI was actually ready. Compose is asynchronous, so things don’t always update right away. The ComposeTestRule gives you tools for this, like waitForIdle(), which just pauses the test until the UI settles down. If you need more control, waitUntil() lets you wait for a very specific thing to happen, like an element finally becoming visible. You have to use these waiting mechanisms to prevent flaky tests, which was the exact problem that made their old Espresso setup so painful.
Handling Interactions and Assertions
Actually doing things in the test, clicks, scrolls, typing, is straightforward. The ComposeContentTestRule gives you methods like performClick(), performScrollToNode(), and performTextInput(). Once you’ve found your “follow_button” with its tag, clicking it is as simple as composeTestRule.onNodeWithTag("follow_button").performClick().
Assertions are just as important. You can go way beyond just checking for text or tags by asserting against all kinds of semantic properties. Is an element visible (assertIsDisplayed())? Is it enabled (assertIsEnabled())? Does it have the right content description (assertContentDescriptionEquals())? You’re not just checking if something is on the screen. You’re verifying its actual state and behavior. Connect & Create started using these assertions to confirm that an element both existed and was in the correct interactive state after a user did something.
Screenshot Testing and Integration
Functional UI tests are great for checking behavior, but they’re blind to visual regressions. A button can still be perfectly clickable even if its color is wrong or the text is overflowing its bounds. A functional test won’t care. That’s where screenshot testing comes in. Using a tool like Dropbox’s Differ or Cash App’s Paparazzi, you can take a picture of your Compose UI and compare it to an approved “baseline” snapshot. The tool highlights any pixel differences, flagging a potential visual bug.
The team at Connect & Create went with Paparazzi and wired it directly into their CI/CD pipeline. From then on, every single pull request ran a bunch of screenshot tests that compared the new UI against the golden master versions. If even a single pixel was out of place, the build failed and the developer got an immediate heads-up. This saved their QA team a ton of time on manual visual checks and stopped a lot of visual bugs from ever getting out. For any team that’s serious about UI quality in Compose, this is a must-have.
Getting it integrated had its headaches, of course. Setting up a solid baseline for screenshots that worked across different device configs and themes took some real effort (it always does). But the payoff was a visual safety net that their functional tests could never provide.
Structuring Your Test Suite for Scalability
With the app getting bigger, their test suite had to be well-organized to stay useful. Sarah pushed for a clear, layered structure:
- Unit Tests for Composables: Tiny tests that look at one composable function in isolation and check its output for different inputs.
- Screen-level UI Tests: Bigger tests using
ComposeTestRulefor a whole screen, making sure navigation, data, and user actions all hang together. - Integration Tests: The highest level, checking how different screens or features work together, usually with some mocked dependencies.
This layering makes it much easier to know where to look when something breaks. If a unit test fails, the bug is in that one component. But if a screen-level test fails, you’re probably looking at a state management or integration issue. It’s a modular structure that mirrors how you build apps with Compose in the first place.
They also started writing custom test matchers for their more complex UI widgets. For a custom “Star Rating” composable, for example, they stopped writing tests that asserted against five individual star icons and instead wrote a single custom matcher like hasRating(4). The tests became way more readable and wouldn’t break every time someone refactored the Star Rating’s internals, as long as it still behaved the same from the outside.
A More Confident Development Cycle
By the end of 2026, the testing story at Connect & Create was completely different. The UI test suite went from being a constant headache to a solid safety net. They could deploy new features with confidence because they knew the automated tests would catch most regressions, and the time they burned on manual UI checks dropped by over 60%. Sarah’s team could finally iterate at the speed they wanted. Adopting Compose-specific testing, with its focus on semantics, test tags, and screenshot testing, was a fundamental change in how they built a quality app.
The big takeaway for them was simple: stop trying to make old testing tools work with new frameworks. You have to use the tools and follow the principles designed for the tech you’re actually using. For Jetpack Compose, that means getting comfortable with the semantics tree, using the test rules correctly, and creating those explicit contracts between the UI and your tests with things like Modifier.testTag(). It’s an up-front investment, but you get it back in developer confidence and a more stable product.
Making the switch to a real Jetpack Compose testing strategy takes work. You have to learn new tools and ways of thinking. The gains in efficiency and product quality are worth it, though. If you put in the time to understand the Compose Test Rules and the semantics tree, you can build a maintainable UI testing suite for your Android apps. It’s also a great way for mobile teams to level up on modern development practices.
What is the primary difference between testing traditional Android Views and Jetpack Compose UIs?
The main difference is what your test interacts with. Traditional View tests look at a mutable hierarchy of view objects, usually finding them with resource IDs. Jetpack Compose tests interact with the semantics tree which is a description of the UI’s meaning and accessibility properties. Because they don’t depend on the visual layout, Compose tests are much more likely to survive UI refactors.
Why are test tags important in Jetpack Compose UI testing?
Test tags (using Modifier.testTag()) give you a solid, unique ID for any composable element that won’t change, even if the UI’s text, color, or layout gets completely reworked. This makes your tests far more stable and less likely to break during redesigns by creating a clear, explicit contract between a component and its test.
How can I prevent flaky tests when interacting with Compose UIs?
Flakiness in Compose tests usually happens when your test tries to do something before the UI is ready. Use the ComposeTestRule methods to fix this. waitForIdle() is a great general-purpose tool that waits for the UI to settle down. If you need to wait for something specific, like an element to appear, use waitUntil() to pause the test until that condition is met.
What is screenshot testing and why is it beneficial for Compose UIs?
It’s a process where you take visual snapshots of your Compose UI components or screens and compare them against approved “baseline” images. This is valuable because your functional tests can’t see visual bugs like bad spacing, wrong colors, or text getting cut off. Screenshot tests find these pixel-level differences automatically, which saves a huge amount of manual visual checking.
What are Compose Test Rules and which one should I use?
They are the core of Compose UI testing, like createComposeRule() and createAndroidComposeRule(). They set up the right environment so you can launch your composables, control the test’s clock, and interact with the UI. Use createComposeRule() for simple composables that don’t need any Android framework features. If your UI needs things like resources, permissions, or an Activity context, you’ll need to use createAndroidComposeRule().
