Android Automation: Using Espresso for UI Testing

Developed by Google, Espresso is a popular Android automation testing framework known for its high performance. It allows you to create simple and direct tests without worrying about the application’s infrastructure. Being open-source, developers can customize it as needed. Research from the University of Oulu shows that Espresso is extremely fast, with the shortest test execution time and minimal errors.

You can use Espresso to test both Java and Kotlin languages. It synchronizes your test actions with the application UI and supports testing of native and hybrid views of Android applications. Additionally, Espresso facilitates black-box and component testing and provides functional testing annotations and assertions. It is also integrated with Google’s Android Studio.

In this blog post, we will explore Espresso, an Android automation testing framework for UI testing.

What is Espresso?

Espresso is a widely used, open-source framework for testing Android applications. It is designed to make writing reliable and efficient UI tests for Android apps more accessible. Developers can interact with and verify the behavior of various user interface components.

Espresso offers a user-friendly API and automatic synchronization with the UI thread, streamlining the testing process and ensuring actions and assertions are performed correctly. It also manages test orchestration, launches the target app, and runs tests in a controlled environment.

Why is Espresso testing Important?

If you’re working on an Android project, validating your work across various stages like build, development, and testing can be challenging. Here are some reasons why Android UI testing is essential:

– Every Android build needs validation after a code commit.

– Relying on remote servers can slow down test execution.

– Testing Android apps requires the latest APIs from Android OS to support new platform features.

– Android app testing should be done on online Android emulators and real devices.

You can write reliable Android UI tests using the Espresso framework, achieve fast test execution, and reduce test flakiness.

Key Features of Espresso Framework

Some of the key features of the Espresso framework include:

• Synchronization Capabilities: The Espresso framework ensures that the UI or application under test has been initiated before your test begins. It verifies the completion of background tasks. Espresso also supports idling resources, which manage asynchronous actions that impact UI tests. Espresso validates these asynchronous actions during Android app testing by registering idle resources.
• Android Intents: Android Intents allow your application to interact with the Android System and third-party apps. Using Espresso, you can control Android Intents’ behavior by stubbing them to provide predefined responses. This approach strengthens tests by minimizing reliance on changes in external apps with each update. Stubbed or Mocked Intents also decrease the frequency of automated test failures caused by issues in external applications.
• Espresso automatically synchronizes with user-interface elements and test actions.
• It is highly flexible and scalable, featuring simple and lightweight APIs that are easy to learn and maintain.
• Espresso supports both Unit testing and Black-box testing.
• It includes a dedicated module for testing UI components within Android WebView and for testing and mocking Android Intents.
• Developers can obtain rapid feedback on code changes and expedite debugging and issue resolution.
• Espresso operates directly alongside the application, delivering instant test results without relying on a server like Selenium RemoteWebDriver.

How do you Create UI tests for Espresso?

Writing UI test cases in Java and Kotlin:

Java:

@Before on view(withId(R.id.my_view),withText(“Hello! Ready to perform Espresso testing”)) .perform(typeText(“Hello! Ready to perform Espresso testing”),click()) .check(matches(withText(“Hello! Ready to perform Espresso testing”)));

Kotlin:

onView(withId(R.id.my_view),withText(“Hello! Ready to perform Espresso testing”)) .perform(typeText(“Hello! Ready to perform Espresso testing”),click()) .check(matches(withText(“Hello! Ready to perform Espresso testing”)))

The test cases above are written in Java and Kotlin to identify a view with a specific ID and unique feature. In this instance, the test script displays the message, “Hello! Ready to perform Espresso testing.” 

The test script performs two actions on this view: it types “Hello! Ready to perform Espresso testing” in a text box and then clicks a button. After the button is clicked, it verifies if the view displays the message by calling the assertion matches(). Once the test passes, you will see the desired text in the view.

How to Run Your First Espresso Test?

Espresso is an excellent framework to include in your test automation strategy, so executing Espresso testing efficiently is essential. You have two options: set up Android device labs or use real-device cloud platforms like LambdaTest for test execution. While setting up Android device labs can be costly and complex to scale, a real device cloud platform removes the hassle of maintaining an in-house device lab.

LambdaTest is an AI-powered test web and mobile test execution platform that lets you run manual and automated tests across 3000+ browsers and OS combinations.  With this platform, you can test your application for Andriod Emulator Mac,  Andriod Emulator, and iOS Simulators, including real device testing with a wide range of mobile device labs.

Here are the steps to follow for Android app testing with Espresso:

Step 1: Upload Your Application

Use our REST API to upload your Android application (.apk file) to the LambdaTest servers. Authenticate by providing your Username and AccessKey in the format ‘Username:AccessKey’ within the cURL command. Be sure to include the appFile’s path in the cURL request.

Step 2: Uploading Test Suite

The next step is to upload the test suite (.apk file) to the LambdaTest servers using our REST API. Authenticate by including your Username and AccessKey in the format ‘Username:AccessKey’ within the cURL command. Make sure to specify the appFile’s path in the cURL request.

Step 3: Executing the Test

After successfully uploading your app and test suite, you can execute your test by running the required command.

Step 4: View Test Execution

After running your tests, you can review the test execution details and logs. This lets you check the status of each test case, whether it passed or failed. You can easily access this information on the LambdaTest Automation platform.

Step 5: Running Tests in Parallel

To run tests concurrently on multiple devices, use the execute command and list the device names in a comma-separated format.

End Note

Espresso stands out as a robust testing framework tailored for Android app developers. It offers a straightforward API, automatic synchronization, and streamlined test orchestration, making UI testing for Android apps easier.

Elevate your Espresso testing with a cloud testing platform such as LambdaTest, designed to optimize your testing efforts and achieve excellent outcomes. LambdaTest allows you to concentrate on testing while it handles the intricacies of infrastructure management seamlessly.