home / skills / secondsky / claude-skills / mobile-app-testing

This skill helps you implement mobile app testing strategies across unit, integration and E2E layers with React Native, iOS and Android tooling.

npx playbooks add skill secondsky/claude-skills --skill mobile-app-testing

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.5 KB
---
name: mobile-app-testing
description: Mobile app testing with unit tests, UI automation, performance testing. Use for test infrastructure, E2E tests, testing standards, or encountering test framework setup, device farms, flaky tests, platform-specific test errors.
keywords: mobile testing, unit testing, UI automation, E2E testing, Jest, XCTest, JUnit, Detox, Espresso, Appium, React Native testing, iOS testing, Android testing, test framework, device farms, flaky tests, mobile test automation, integration testing, testing pyramid, test coverage
---

# Mobile App Testing

Implement comprehensive testing strategies for mobile applications.

## Testing Pyramid

| Level | Tools | Coverage |
|-------|-------|----------|
| Unit | Jest, XCTest, JUnit | 70% |
| Integration | Detox, Espresso | 20% |
| E2E | Appium, Detox | 10% |

## React Native (Jest + Detox)

```javascript
// Unit test
describe('CartService', () => {
  it('calculates total correctly', () => {
    const cart = new CartService();
    cart.addItem({ price: 10, quantity: 2 });
    expect(cart.getTotal()).toBe(20);
  });
});

// E2E test (Detox)
describe('Login flow', () => {
  beforeEach(async () => {
    await device.reloadReactNative();
  });

  it('should login successfully', async () => {
    await element(by.id('email-input')).typeText('[email protected]');
    await element(by.id('password-input')).typeText('password123');
    await element(by.id('login-button')).tap();
    await expect(element(by.id('dashboard'))).toBeVisible();
  });
});
```

## iOS (XCTest)

```swift
func testLoginSuccess() {
    let app = XCUIApplication()
    app.launch()

    app.textFields["email"].tap()
    app.textFields["email"].typeText("[email protected]")
    app.secureTextFields["password"].typeText("password123")
    app.buttons["Login"].tap()

    XCTAssertTrue(app.staticTexts["Welcome"].exists)
}
```

## Android (Espresso)

```kotlin
@Test
fun loginSuccess() {
    onView(withId(R.id.email)).perform(typeText("[email protected]"))
    onView(withId(R.id.password)).perform(typeText("password123"))
    onView(withId(R.id.loginButton)).perform(click())
    onView(withId(R.id.dashboard)).check(matches(isDisplayed()))
}
```

## Best Practices

- Test business logic first (unit tests)
- Mock external dependencies
- Test both success and failure paths
- Automate critical user flows
- Maintain >80% code coverage
- Test on real devices periodically

## Avoid

- Testing implementation details
- Hardcoded test data
- Interdependent tests
- Skipping error case testing

Overview

This skill provides a production-ready approach to mobile app testing covering unit tests, UI automation, and performance checks. It includes patterns and examples for React Native, iOS, and Android, plus guidance for test infrastructure and device farms. The focus is practical: reduce flakiness, validate critical user flows, and keep tests maintainable and fast.

How this skill works

The skill maps the testing pyramid to concrete tools: Jest/XCTest/JUnit for unit tests, Detox/Espresso for integration, and Appium/Detox for end-to-end scenarios. It supplies examples for common flows (login, cart calculations) and prescribes mocking, device selection, and CI strategies. Use it to inspect failing tests, configure frameworks, or design a balanced test suite across layers.

When to use it

  • Setting up or standardizing test infrastructure for a mobile project
  • Adding E2E or UI automation for critical user journeys
  • Diagnosing flaky tests or platform-specific test failures
  • Planning test coverage and shifting-left testing efforts
  • Integrating device farm runs into CI/CD pipelines

Best practices

  • Start with unit tests for business logic before automating UI flows
  • Mock external dependencies to keep tests deterministic
  • Automate only critical user flows in E2E to limit maintenance
  • Run tests on a mix of emulators and real devices regularly
  • Avoid testing implementation details and hardcoded data

Example use cases

  • Write Jest unit tests for a React Native cart service and run in CI
  • Create Detox E2E tests for login and checkout flows on iOS and Android
  • Use XCTest and Espresso snippets to reproduce platform-specific UI bugs
  • Integrate Appium with a device farm for cross-device compatibility checks
  • Identify and isolate flaky tests, then add retries or improve selectors

FAQ

What testing coverage should I target?

Aim for high unit test coverage (60–80%) and keep integration/E2E targeted; overall coverage targets depend on risk but maintain >80% on critical logic where feasible.

How do I reduce flaky UI tests?

Use stable selectors, avoid timing-based assertions, reset app state between tests, mock network where appropriate, and run on real devices to reproduce flakiness.