Skip to main content
skill CX Codex

espresso-skill — Claude Code skill for Android UI tests and setup

Generate Espresso UI tests for Android apps written in Kotlin or Java. Use the skill to exercise screen interactions and check what the interface displays afterward.

MIT 234 installs ★ 393 updated 2026-10-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add LambdaTest/agent-skills --skill espresso-skill -a claude-code
Open on GitHub

What espresso-skill does

The skill creates Android screen tests that locate views by ID, text, or accessibility description, perform input and gestures, then check visibility, text, and view state. It also covers actions on RecyclerView items. Kotlin is used in the examples, and Java is supported too.

Run tests locally with ./gradlew connectedAndroidTest, or prepare them for TestMu AI cloud devices by building and uploading the app APK and test APK, then launching a run through the API. The Gradle guidance includes AndroidJUnitRunner and Espresso dependencies. For typed input, the examples close the soft keyboard; for asynchronous network work, they use IdlingResource rather than Thread.sleep().

What it helps with

  • generate a login test that checks the successful result
  • verify an error message after invalid credentials
  • locate a view by ID, text, or accessibility description
  • exercise items in a RecyclerView
  • prepare Espresso tests for TestMu AI real-device runs

Example prompts for the agent

  • Write an Espresso test for the login screen and verify that a successful sign-in opens the dashboard.
  • Add a test that checks the error shown after an invalid password.
  • Prepare my Android UI tests for a TestMu AI real-device run.

How to install espresso-skill

1Skills CLI (Vercel)

npx skills add LambdaTest/agent-skills --skill espresso-skill -a claude-code

2Manually: put the files in place

~/.claude/skills/espresso-skill/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/espresso-skill/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about espresso-skill

How do I install espresso-skill in Claude Code?

Run npx skills add LambdaTest/agent-skills --skill espresso-skill -a claude-code. The skill file is at ~/.claude/skills/espresso-skill/SKILL.md.

What does espresso-skill do?

It helps generate Espresso UI tests for Android in Kotlin or Java, including view matching, interactions, and checks on screen state.

Can I run tests locally and in the cloud?

Yes. Run locally with ./gradlew connectedAndroidTest; for TestMu AI, the skill describes building and uploading both APKs before starting a run through the API.

Source text

SKILL.md · MIT
---
name: espresso-skill
description: >
  Generates Espresso UI tests for Android apps in Kotlin or Java. Espresso runs
  inside the app process for fast, reliable UI testing. Supports local and TestMu AI
  cloud real devices. Use when user mentions "Espresso", "onView", "ViewMatchers",
  "Android UI test", or "instrumentation test". Triggers on: "Espresso",
  "onView", "ViewMatchers", "Android UI test", "instrumentation", "TestMu".
languages:
  - Java
  - Kotlin
category: mobile-testing
license: MIT
metadata:
  author: TestMu AI
  version: "1.0"
---

# Espresso Automation Skill

You are a senior Android QA engineer specializing in Espresso UI testing.

## Step 1 — Execution Target

```
├─ Mentions "cloud", "TestMu", "LambdaTest", "device farm"?
│  └─ TestMu AI cloud (upload APK + test APK)
│
├─ Mentions "emulator", "local", "connected device"?
│  └─ Local: ./gradlew connectedAndroidTest
│
└─ Default → Local emulator
```

## Core Patterns — Kotlin (Default)

### Basic Test

```kotlin
@RunWith(AndroidJUnit4::class)
class LoginTest {

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

    @Test
    fun loginWithValidCredentials() {
        // Type email
        onView(withId(R.id.emailInput))
            .perform(typeText("[email protected]"), closeSoftKeyboard())

        // Type password
        onView(withId(R.id.passwordInput))
            .perform(typeText("password123"), closeSoftKeyboard())

        // Click login button
        onView(withId(R.id.loginButton))
            .perform(click())

        // Verify dashboard is displayed
        onView(withId(R.id.dashboardTitle))
            .check(matches(isDisplayed()))
            .check(matches(withText("Welcome")))
    }

    @Test
    fun loginWithInvalidCredentials_showsError() {
        onView(withId(R.id.emailInput))
            .perform(typeText("[email protected]"), closeSoftKeyboard())
        onView(withId(R.id.passwordInput))
            .perform(typeText("wrong"), closeSoftKeyboard())
        onView(withId(R.id.loginButton))
            .perform(click())
        onView(withId(R.id.errorText))
            .check(matches(isDisplayed()))
            .check(matches(withText(containsString("Invalid"))))
    }
}
```

### ViewMatchers (Finding Elements)

```kotlin
// By ID (best)
onView(withId(R.id.loginButton))

// By text
onView(withText("Login"))

// By content description (accessibility)
onView(withContentDescription("Submit form"))

// By hint text
onView(withHint("Enter your email"))

// Combined matchers
onView(allOf(withId(R.id.button), withText("Submit"), isDisplayed()))

// In RecyclerView
onView(withId(R.id.recyclerView))
    .perform(RecyclerViewActions.actionOnItemAtPosition<ViewHolder>(0, click()))

// By parent
onView(allOf(withText("Delete"), isDescendantOfA(withId(R.id.toolbar))))
```

### ViewActions (Performing Actions)

```kotlin
.perform(click())                          // Tap
.perform(longClick())                      // Long press
.perform(typeText("hello"))                // Type text
.perform(replaceText("new text"))          // Replace text
.perform(clearText())                      // Clear field
.perform(closeSoftKeyboard())              // Dismiss keyboard
.perform(scrollTo())                       // Scroll to element
.perform(swipeUp())                        // Swipe gesture
.perform(swipeDown())
.perform(swipeLeft())
.perform(swipeRight())
.perform(pressBack())                      // Back button
```

### ViewAssertions (Checking State)

```kotlin
.check(matches(isDisplayed()))             // Visible
.check(matches(not(isDisplayed())))        // Not visible
.check(matches(withText("Expected")))      // Text matches
.check(matches(isEnabled()))               // Enabled
.check(matches(isChecked()))               // Checkbox checked
.check(matches(hasErrorText("Required")))  // Error text
.check(doesNotExist())                     // Not in hierarchy
```

### Idling Resources (Async Operations)

```kotlin
// Register before test
@Before
fun setUp() {
    IdlingRegistry.getInstance().register(myIdlingResource)
}

// Unregister after test
@After
fun tearDown() {
    IdlingRegistry.getInstance().unregister(myIdlingResource)
}

// Custom IdlingResource for network calls
class NetworkIdlingResource : IdlingResource {
    private var callback: IdlingResource.ResourceCallback? = null
    private var isIdle = true

    override fun getName() = "NetworkIdlingResource"
    override fun isIdleNow() = isIdle
    override fun registerIdleTransitionCallback(callback: ResourceCallback) {
        this.callback = callback
    }

    fun setIdle(idle: Boolean) {
        isIdle = idle
        if (idle) callback?.onTransitionToIdle()
    }
}
```

### Anti-Patterns

| Bad | Good | Why |
|-----|------|-----|
| `Thread.sleep()` | IdlingResources | Espresso auto-syncs UI thread |
| XPath-like traversal | `withId(R.id.x)` | Direct ID is fastest |
| Testing across activities | Test single screen, mock data | Isolation |
| No `closeSoftKeyboard()` | Always close after `typeText()` | Keyboard blocks elements |

### TestMu AI Cloud

```bash
# 1. Build APK and test APK
./gradlew assembleDebug assembleDebugAndroidTest

# 2. Upload both to LambdaTest
curl -u "$LT_USERNAME:$LT_ACCESS_KEY" \
  -X POST "https://manual-api.lambdatest.com/app/upload/realDevice" \
  -F "appFile=@app/build/outputs/apk/debug/app-debug.apk" \
  -F "type=android"

curl -u "$LT_USERNAME:$LT_ACCESS_KEY" \
  -X POST "https://manual-api.lambdatest.com/app/upload/realDevice" \
  -F "appFile=@app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk" \
  -F "type=android"

# 3. Execute on real devices via API
curl -u "$LT_USERNAME:$LT_ACCESS_KEY" \
  -X POST "https://mobile-api.lambdatest.com/framework/v1/espresso/build" \
  -H "Content-Type: application/json" \
  -d '{
    "app": "lt://APP123",
    "testSuite": "lt://TEST456",
    "device": ["Pixel 8-14", "Galaxy S24-14"],
    "build": "Espresso Cloud Build",
    "video": true, "deviceLog": true
  }'
```

## build.gradle Setup

```groovy
android {
    defaultConfig {
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
}

dependencies {
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.5.1'
    androidTestImplementation 'androidx.test.espresso:espresso-intents:3.5.1'
    androidTestImplementation 'androidx.test:runner:1.5.2'
    androidTestImplementation 'androidx.test:rules:1.5.0'
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
}
```

## Quick Reference

| Task | Command/Code |
|------|-------------|
| Run all tests | `./gradlew connectedAndroidTest` |
| Run specific class | `./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.example.LoginTest` |
| Run on specific device | `./gradlew connectedAndroidTest -PtestDevice=emulator-5554` |
| Intent verification | `Intents.init()` → `intended(hasComponent(...))` → `Intents.release()` |
| RecyclerView scroll | `RecyclerViewActions.scrollToPosition<>(10)` |
| Screenshot | `Screenshot.capture(activityRule.activity)` |

## Reference Files

| File | When to Read |
|------|-------------|
| `reference/cloud-integration.md` | LambdaTest Espresso, device farm, API |
| `reference/advanced-patterns.md` | Intents, RecyclerView, custom matchers |

## Deep Patterns → `reference/playbook.md`

| § | Section | Lines |
|---|---------|-------|
| 1 | Project Setup | Gradle deps, Orchestrator |
| 2 | Test Structure & Lifecycle | Rules, permissions, annotations |
| 3 | Custom Matchers & ViewActions | RecyclerView, wait, scroll |
| 4 | RecyclerView Testing | Scroll, click child, swipe, assert |
| 5 | Idling Resources | Counting, OkHttp, custom |
| 6 | Intent Testing | Share, stub, camera |
| 7 | MockWebServer for API Tests | Enqueue, error handling |
| 8 | CI/CD Integration | GitHub Actions, emulator runner |
| 9 | Debugging Quick-Reference | 10 common problems |
| 10 | Best Practices Checklist | 13 items |

© TestMu AI · MIT · LambdaTest/agent-skills

Similar skills

All skills for Testing and QA →

From the same set47

The whole set →
smartui-skill This skill prepares SmartUI visual regression tests for screenshot comparison. Use it to check pages and components across browsers and viewports. CX Codex +1 237installs jasmine-skill Generates test specs in Jasmine for JavaScript and TypeScript. Includes BDD patterns, spy and mock syntax, async support — the code editor writes describe, it, expect, and spy calls automatically. CX Codex +1 237installs mocha-skill Creates Mocha tests for JavaScript and TypeScript with Chai assertions and Sinon mocks. Useful when a project needs unit-test scaffolding. CX Codex +1 235installs unittest-skill Generates Python unittest tests with TestCase, setUp/tearDown, and assertion methods. Triggers when you mention unittest, TestCase, or self.assertEqual. CX Codex +1 235installs laravel-dusk-skill Generates E2E tests with Laravel Dusk. The agent writes PHP code with $browser->visit, form checks, and Page Objects. CX Codex +1 231installs test-framework-migration-skill test-framework-migration-skill converts E2E test scripts between Selenium, Playwright, Puppeteer, and Cypress. It rewrites selectors, assertions, and lifecycle methods automatically. CX Codex +1 229installs behave-skill Generate Python BDD tests with Gherkin feature files and Behave step implementations. Useful when you need to turn user flows into runnable scenarios. CX Codex +1 227installs karma-skill Builds karma.conf.js for browser-based JavaScript tests on Jasmine, Mocha or QUnit, and shows how to run the suite. CX Codex +1 226installs

Project sponsors

Companies that keep this analytics open