Deep Dive into Android: Java with Espresso and Appium

Espresso vs Appium: What Problem Are You Solving?

Inside Espresso: Instrumentation and Synchronization

Wiring a Simple Espresso Test in Java

From a tester's perspective, adding Espresso to an Android app means:

1. Adding test dependencies
2. Using AndroidJUnitRunner
3. Writing tests with `onView`, `withId`, `perform`, and `check`

Below is a minimal Java example that logs in and checks a greeting message.

```gradle

// app/build.gradle (Groovy DSL; for Kotlin DSL the syntax is similar)

android {

defaultConfig {

testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

}

}

dependencies {

androidTestImplementation "androidx.test.ext:junit:1.2.1" // or latest stable

androidTestImplementation "androidx.test.espresso:espresso-core:3.6.1" // or latest stable

}

```

```java

// Example: src/androidTest/java/com/example/LoginTest.java

package com.example;

import static androidx.test.espresso.Espresso.onView;

import static androidx.test.espresso.action.ViewActions.click;

import static androidx.test.espresso.action.ViewActions.typeText;

import static androidx.test.espresso.action.ViewActions.closeSoftKeyboard;

import static androidx.test.espresso.assertion.ViewAssertions.matches;

import static androidx.test.espresso.matcher.ViewMatchers.withId;

import static androidx.test.espresso.matcher.ViewMatchers.withText;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import androidx.test.rule.ActivityTestRule;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

@RunWith(AndroidJUnit4.class)

public class LoginTest {

@Rule

public ActivityTestRule<MainActivity> activityRule =

new ActivityTestRule<>(MainActivity.class);

@Test

public void successfulLogin_showsGreeting() {

// Type username

onView(withId(R.id.username))

.perform(typeText("alice"), closeSoftKeyboard());

// Type password

onView(withId(R.id.password))

.perform(typeText("password123"), closeSoftKeyboard());

// Tap login button

onView(withId(R.id.login_button))

.perform(click());

// Espresso waits for UI/async work, then we assert

onView(withId(R.id.greeting))

.check(matches(withText("Welcome, alice!")));

}

}

```

Notice there are no explicit waits. Espresso handles synchronization based on the UI thread and background tasks.

Espresso in Practice: Fragments, RecyclerView, and Compose

Appium on Android: WebDriver-Style Control

Thought Exercise: Choosing Espresso or Appium

Combining Espresso Checks with Appium Flows

You cannot literally run Espresso and Appium in the same test method, but you can design a pipeline where:

• Espresso handles deep Android validation (fast, stable, many tests).
• Appium handles cross-platform and end-to-end flows (fewer, broader tests).

A practical Java-centric strategy:

1. Espresso module inside the Android project

• Contains instrumentation tests.
• Run on every commit or pull request.

1. Appium module in a separate test project

• Uses Java + TestNG or JUnit.
• Talks to Android and iOS devices.

1. Share test data and contracts

• Use common JSON fixtures or API contracts.
• Keep page/screen object naming consistent.

Below is a simplified Appium Java test that aligns with an Espresso test for the same login flow:

```java

// Appium-based cross-platform login test (Android flavor)

import io.appium.java_client.MobileElement;

import io.appium.java_client.android.AndroidDriver;

import org.openqa.selenium.By;

import org.openqa.selenium.support.ui.ExpectedConditions;

import org.openqa.selenium.support.ui.WebDriverWait;

public class LoginFlowTest {

private AndroidDriver driver;

// driver initialization omitted for brevity

@Test

public void loginshowsGreetingcrossPlatform() {

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

MobileElement username = (MobileElement) wait.until(

ExpectedConditions.visibilityOfElementLocated(

By.id("com.example:id/username"))

);

username.sendKeys("alice");

driver.findElement(By.id("com.example:id/password"))

.sendKeys("password123");

driver.findElement(By.id("com.example:id/login_button")).click();

MobileElement greeting = (MobileElement) wait.until(

ExpectedConditions.visibilityOfElementLocated(

By.id("com.example:id/greeting"))

);

assertEquals("Welcome, alice!", greeting.getText());

}

}

```

In your CI strategy:

• Run Espresso suite frequently (per commit) for Android-specific correctness.
• Run Appium suite less frequently (e.g., nightly or per release) for cross-platform end-to-end sanity.

This split mirrors how many teams in 2024–2026 organize mobile testing in industry.

Quiz: Synchronization and Tool Choice

Answer this question to check your understanding of Espresso vs Appium and synchronization.

Key Term Review: Espresso, Appium, and Android UI

Flip through these cards to reinforce the core concepts from this module.