Learn more about UI Testing with Espresso

Utilising UI Automation with Android Espresso reduces costs and saves time during development cycles. While it's true that the initial cost in both money and time is high, studies have proven that the ROI on Automated Testing is always higher.

The Automation Test Framework Espresso is created and maintained by Google and allows for performing both black-box testing and individual component testing. The syntax allows for writing clear and concise tests, with expectations, interactions and assertions.

There's an Android Espresso Recorder available as well, which provides a no-code approach to creating Espresso testcases. Once a recording is finished, the Recorder will generate UI test code based from the interactions you performed while recording.

You can easily run Espresso tests from inside of Android Studio, locally on your machine. Espresso supports Android 4.4 all the way up to the latest version.

The framework allows for accessibility testing as well.

To add Espresso automated testing to your Android project, you will need to add some dependencies to your app's build.gradle file. You will also need to add the testInstrumentationRunner to the same build.gradle file, in the android.defaultConfig section.

Now that you've added the dependencies, simply resync or rebuild the project.
Your build.gradle file should look similar to this:

Once you've added the necessary dependencies to run Espresso tests, you can add your first Espresso UI test to your project.
Usually you would put these files in src/androidTest/java/com.example.package/.

@RunWith(AndroidJUnit4::class)
@LargeTest
class FirstEspressoTest {

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

    @Test fun justATest() {
        onView(withText("Hello world!")).check(matches(isDisplayed()))
    }
}

There are multiple great alternatives to Espresso. Please see the list below:

• Kaspresso
  

  This framework is based on Espresso and UI Automator, with some interesting features.

  • Robolectric support
  • Allure support
  • Very clear usage of DSL
  • Jetpack Compose support
• Barista
  

  While staying in the same coffee naming scheme, this framework's purpose is to make creating tests easier, by removing the need to write boilerplate code.

  A retry strategy is provided, which should improve stability and flakiness of tests. Another great feature is the automatic scrolling in ScrollView components.

• BusyBee
  

  BusyBee is not an alternative to Espresso, but rather an extension. It provides an alternative API for IdlingResources in Espresso tests, which might improve the performance and reliability of your tests.

• Robolectric
  

  Robolectric allows you to run tests without a device or even emulator. It will run tests in a sandbox, simulating an Android Environment inside a JVM.

Android Espresso tests can run on both Android Emulators and physical Android devices.

You can use Gradle or Android Studio to run the UI tests on one or more emulators running on your machine.

If you are looking to run Android Espresso tests at scale, on either emulators or physical Android devices, at TestingBot we provide a large grid of emulators and devices ready to run your Espresso tests.

Both Appium and Espresso are test frameworks providing automation on Android.

Appium provides a service, compatible with Selenium clients using the WebDriver W3C protocol.
It uses UIAutomator and Espresso functionality at its core to instrument Android devices and apps for automated QA testing.

Espresso is the framework, built by Google, to provide UI automation on Android environments.

One of the differences is that Espresso only supports Java or Kotlin, while Appium provides client bindings for multiple languages, such as Java, Ruby, C#, PHP and Python.