mobile-testing-frameworks

name	Mobile Testing Frameworks
description	Comprehensive mobile testing framework expertise
version	1.0.0
category	Quality Assurance
slug	mobile-testing
status	active
graph	{"domains":["domain:mobile"],"specializations":["specialization:mobile-development"],"skillAreas":["skill-area:mobile-ui-automation","skill-area:cross-platform-testing"],"roles":["role:mobile-engineer"],"workflows":["workflow:feature-development","workflow:release-management"],"topics":["topic:accessibility"]}

Mobile Testing Frameworks Skill

Overview

This skill provides comprehensive expertise in mobile testing frameworks across platforms. It enables E2E testing with Detox and Maestro, native testing with XCUITest and Espresso, and cross-platform testing with Appium.

Allowed Tools

• bash - Execute test commands and framework CLIs
• read - Analyze test files and configurations
• write - Generate test cases and configurations
• edit - Update existing tests
• glob - Search for test files
• grep - Search for patterns in test code

Capabilities

Detox (React Native)

1. Configuration

   • Set up Detox configurations
   • Configure iOS and Android builds
   • Set up device/simulator targets
   • Configure test runners (Jest)

2. Test Writing

   • Write element matchers
   • Implement actions (tap, type, scroll)
   • Configure expectations
   • Handle synchronization

3. Advanced Features

   • Mock native modules
   • Handle permissions
   • Configure network mocking
   • Implement visual regression

Maestro

4. Flow Configuration

   • Write YAML test flows
   • Configure app launch
   • Set up device targets
   • Handle environment variables

5. Actions and Assertions

   • Tap, type, swipe gestures
   • Assert element visibility
   • Take screenshots
   • Run JavaScript assertions

XCUITest (iOS)

6. Test Setup

   • Configure test schemes
   • Set up test plans
   • Configure device targets
   • Handle launch arguments

7. UI Testing

   • Element queries with XCUIElement
   • Actions (tap, swipe, pinch)
   • Accessibility identifier usage
   • Keyboard handling

Espresso (Android)

8. Test Configuration

   • Set up instrumentation tests
   • Configure test runner
   • Handle Hilt injection
   • Configure Compose testing

9. UI Testing

   • ViewMatchers and ViewActions
   • Compose semantics testing
   • IdlingResources for async
   • Intent verification

Appium

10. Cross-Platform Testing
    • Configure capabilities
    • Set up driver sessions
    • Handle multiple platforms
    • Configure cloud testing

Device Farms

11. Cloud Testing
    • AWS Device Farm integration
    • Firebase Test Lab setup
    • BrowserStack configuration
    • Test distribution

Target Processes

This skill integrates with the following processes:

• mobile-testing-strategy.js - Testing strategy implementation
• mobile-accessibility-implementation.js - Accessibility testing
• mobile-security-implementation.js - Security testing

Dependencies

Required

• Node.js (for Detox, Maestro)
• Xcode (for XCUITest)
• Android Studio (for Espresso)
• Platform-specific SDKs

Optional

• Appium
• Device farm accounts
• CI/CD platform

Configuration

Detox Configuration

// .detoxrc.js
module.exports = {
  testRunner: {
    args: {
      $0: 'jest',
      config: 'e2e/jest.config.js',
    },
    jest: {
      setupTimeout: 120000,
    },
  },
  apps: {
    'ios.debug': {
      type: 'ios.app',
      binaryPath: 'ios/build/Build/Products/Debug-iphonesimulator/MyApp.app',
      build: 'xcodebuild -workspace ios/MyApp.xcworkspace -scheme MyApp -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build',
    },
    'ios.release': {
      type: 'ios.app',
      binaryPath: 'ios/build/Build/Products/Release-iphonesimulator/MyApp.app',
      build: 'xcodebuild -workspace ios/MyApp.xcworkspace -scheme MyApp -configuration Release -sdk iphonesimulator -derivedDataPath ios/build',
    },
    'android.debug': {
      type: 'android.apk',
      binaryPath: 'android/app/build/outputs/apk/debug/app-debug.apk',
      build: 'cd android && ./gradlew assembleDebug assembleAndroidTest -DtestBuildType=debug',
      reversePorts: [8081],
    },
    'android.release': {
      type: 'android.apk',
      binaryPath: 'android/app/build/outputs/apk/release/app-release.apk',
      build: 'cd android && ./gradlew assembleRelease assembleAndroidTest -DtestBuildType=release',
    },
  },
  : {
    : {
      : ,
      : { :  },
    },
    : {
      : ,
      : { :  },
    },
  },
  : {
    : {
      : ,
      : ,
    },
    : {
      : ,
      : ,
    },
    : {
      : ,
      : ,
    },
    : {
      : ,
      : ,
    },
  },
};

Usage Examples

Detox Test

// e2e/login.test.ts
import { device, element, by, expect } from 'detox';

describe('Login Flow', () => {
  beforeAll(async () => {
    await device.launchApp({
      newInstance: true,
      permissions: { notifications: 'YES' },
    });
  });

  beforeEach(async () => {
    await device.reloadReactNative();
  });

  it('should show login screen on first launch', async () => {
    await expect(element(by.id('login-screen'))).toBeVisible();
    await expect(element(by.id('email-input'))).toBeVisible();
    await expect(element(by.id('password-input'))).toBeVisible();
  });

  it('should show error for invalid credentials', async () => {
    await element(by.id('email-input')).();
     (by.()).();
     (by.()).();

     ((by.())).();
     ((by.())).();
  });

  (,  () => {
     (by.()).();
     (by.()).();
     (by.()).();

     ((by.()))
      .()
      .();

     ((by.())).();
  });

  (,  () => {
    
     (by.()).();
     (by.()).();
     (by.()).();

     ((by.())).().();

    
     (by.()).();
     ((by.())).();

    
     (by.()).();
     ((by.())).();
  });
});

Maestro Flow

# flows/login.yaml
appId: com.example.myapp
---
- launchApp:
    clearState: true

- assertVisible: "Welcome"

- tapOn: "Email"
- inputText: "[e-mail]"

- tapOn: "Password"
- inputText: "password123"

- tapOn: "Sign In"

- assertVisible: "Home"
- takeScreenshot: "home_after_login"

# Test logout flow
- tapOn: "Profile"
- tapOn: "Sign Out"
- assertVisible: "Welcome"

XCUITest

// MyAppUITests/LoginTests.swift
import XCTest

final class LoginTests: XCTestCase {
    var app: XCUIApplication!

    override func setUpWithError() throws {
        continueAfterFailure = false
        app = XCUIApplication()
        app.launchArguments = ["--uitesting"]
        app.launch()
    }

    override func tearDownWithError() throws {
        app = nil
    }

    func testLoginScreenElements() throws {
        XCTAssertTrue(app.textFields["email-input"].exists)
        XCTAssertTrue(app.secureTextFields["password-input"].exists)
        XCTAssertTrue(app.buttons["login-button"].exists)
    }

    func testSuccessfulLogin() throws {
        let emailField = app.textFields["email-input"]
        let passwordField = app.secureTextFields["password-input"]
        let loginButton = app.buttons["login-button"]

        emailField.tap()
        emailField.typeText("[e-mail]")

        passwordField.tap()
        passwordField.typeText()

        loginButton.tap()

        
         homeScreen  app.otherElements[]
        (homeScreen.waitForExistence(timeout: ))
    }

     ()  {
        app.textFields[].tap()
        app.textFields[].typeText()

        app.secureTextFields[].tap()
        app.secureTextFields[].typeText()

        app.buttons[].tap()

        (app.staticTexts[].waitForExistence(timeout: ))
    }

     ()  {
        
        app.buttons[].tap()

         list  app.tables[]
         lastItem  app.cells[]

        
         lastItem.isHittable {
            list.swipeUp()
        }

        (lastItem.exists)

        
         firstItem  app.cells[]
         firstItem.isHittable {
            list.swipeDown()
        }

        (firstItem.exists)
    }
}

Espresso Test

// app/src/androidTest/java/com/example/myapp/LoginTest.kt
package com.example.myapp

import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createAndroidComposeRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import dagger.hilt.android.testing.HiltAndroidRule
import dagger.hilt.android.testing.HiltAndroidTest
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@HiltAndroidTest
@RunWith(AndroidJUnit4::class)
class LoginTest {

    @get:Rule(order = 0)
    val hiltRule = HiltAndroidRule(this)

    @get:Rule(order = 1)
    val composeRule = createAndroidComposeRule<MainActivity>()

    @Before
    fun setup() {
        hiltRule.inject()
    }

    @Test
    fun loginScreen_displaysAllElements() {
        composeRule.onNodeWithTag("email-input").assertIsDisplayed()
        composeRule.onNodeWithTag("password-input").assertIsDisplayed()
        composeRule.onNodeWithTag("login-button").assertIsDisplayed()
    }

    @Test
    fun login_withValidCredentials_navigatesToHome() {
        composeRule.onNodeWithTag("email-input")
            .performTextInput("[e-mail]")

        composeRule.onNodeWithTag()
            .performTextInput()

        composeRule.onNodeWithTag()
            .performClick()

        composeRule.waitUntil() {
            composeRule.onAllNodesWithTag()
                .fetchSemanticsNodes().isNotEmpty()
        }

        composeRule.onNodeWithTag().assertIsDisplayed()
    }

    
     {
        composeRule.onNodeWithTag()
            .performTextInput()

        composeRule.onNodeWithTag()
            .performTextInput()

        composeRule.onNodeWithTag()
            .performClick()

        composeRule.onNodeWithText()
            .assertIsDisplayed()
    }

    
     {
        
        composeRule.onNodeWithTag()
            .performTextInput()
        composeRule.onNodeWithTag()
            .performTextInput()
        composeRule.onNodeWithTag()
            .performClick()

        composeRule.waitUntil() {
            composeRule.onAllNodesWithTag()
                .fetchSemanticsNodes().isNotEmpty()
        }

        
        composeRule.onNodeWithTag()
            .performScrollToNode(hasTestTag())

        composeRule.onNodeWithTag().assertIsDisplayed()
    }
}

Firebase Test Lab

# .github/workflows/android-test.yml
name: Android Tests

on: [push, pull_request]

jobs:
  instrumented-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Build APKs
        run: |
          ./gradlew assembleDebug assembleDebugAndroidTest

      - name: Authenticate to Google Cloud
        uses: google-github-actions/auth@v2
        with:
          credentials_json: ${{ secrets.GCP_CREDENTIALS }}

      - name: Run tests on Firebase Test Lab
        run: 

Quality Gates

Test Coverage

• Unit test coverage > 80%
• Integration test coverage > 60%
• E2E critical path coverage 100%

Test Reliability

• Flaky test rate < 2%
• Test execution time < 15 minutes
• Retry logic for network tests

Accessibility Testing

• VoiceOver/TalkBack verification
• Color contrast validation
• Touch target size verification

Related Skills

• accessibility-testing - Accessibility-focused testing
• mobile-perf - Performance testing
• fastlane-cicd - CI/CD integration

Version History

• 1.0.0 - Initial release with major framework support