Mobile Testing in 2025: iOS, Android and Beyond

// Installing specific drivers
npm install -g appium
appium driver install uiautomator2
appium driver install xcuitest
appium driver install flutter

// Installing useful plugins
appium plugin install images
appium plugin install gestures
appium plugin install element-wait

import { remote } from 'webdriverio';

const capabilities = {
  platformName: 'Android',
  'appium:automationName': 'UiAutomator2',
  'appium:deviceName': 'Android Emulator',
  'appium:app': '/path/to/app.apk',
  'appium:newCommandTimeout': 300,
  'appium:uiautomator2ServerInstallTimeout': 60000,
  // Appium 2.0 specific options
  'appium:skipServerInstallation': false,
  'appium:ensureWebviewsHavePages': true
};

const driver = await remote({
  protocol: 'http',
  hostname: 'localhost',
  port: 4723,
  path: '/wd/hub',
  capabilities
});

// Modern element interaction with improved selectors
const loginButton = await driver.$('~login-button'); // Accessibility ID
await loginButton.click();

// Better gesture support
await driver.execute('mobile: scroll', {
  direction: 'down'
});

await driver.deleteSession();

import XCTest

class LoginFlowTests: XCTestCase {
    var app: XCUIApplication!

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

    func testSuccessfulLogin() throws {
        // Modern query approach with type safety
        let emailField = app.textFields["email-input"]
        XCTAssertTrue(emailField.waitForExistence(timeout: 5))
        emailField.tap()
        emailField.typeText("user@example.com")

        let passwordField = app.secureTextFields["password-input"]
        passwordField.tap()
        passwordField.typeText("SecurePass123!")

        // Using accessibility identifiers
        app.buttons["login-button"].tap()

        // Verify navigation
        let dashboardTitle = app.staticTexts["Dashboard"]
        XCTAssertTrue(dashboardTitle.waitForExistence(timeout: 10))
    }

    func testLoginWithBiometrics() throws {
        // Simulate Face ID authentication
        let biometricButton = app.buttons["biometric-login"]
        biometricButton.tap()

        // Simulate successful biometric authentication
        addUIInterruptionMonitor(withDescription: "Face ID") { alert in
            alert.buttons["Authenticate"].tap()
            return true
        }

        app.tap() // Trigger interruption monitor

        XCTAssertTrue(app.staticTexts["Dashboard"]
            .waitForExistence(timeout: 10))
    }
}

import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.*
import androidx.test.espresso.assertion.ViewAssertions.matches
import androidx.test.espresso.matcher.ViewMatchers.*
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class LoginActivityTest {

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

    @Test
    fun testSuccessfulLogin() {
        // Type email
        onView(withId(R.id.email_input))
            .perform(typeText("user@example.com"), closeSoftKeyboard())

        // Type password
        onView(withId(R.id.password_input))
            .perform(typeText("SecurePass123!"), closeSoftKeyboard())

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

        // Verify navigation to dashboard
        onView(withId(R.id.dashboard_title))
            .check(matches(withText("Dashboard")))
    }

    @Test
    fun testRecyclerViewInteraction() {
        // Test RecyclerView with complex matchers
        onView(withId(R.id.user_list))
            .perform(
                RecyclerViewActions.actionOnItemAtPosition<RecyclerView.ViewHolder>(
                    2, click()
                )
            )

        // Verify detail screen
        onView(withId(R.id.user_detail_name))
            .check(matches(isDisplayed()))
    }

    @Test
    fun testIdlingResourceForAsyncOperations() {
        // Register idling resource for network calls
        val idlingResource = OkHttpIdlingResource.create(
            "okhttp", okHttpClient
        )
        IdlingRegistry.getInstance().register(idlingResource)

        onView(withId(R.id.refresh_button)).perform(click())

        // Espresso automatically waits for idling resource
        onView(withId(R.id.data_list))
            .check(matches(isDisplayed()))

        IdlingRegistry.getInstance().unregister(idlingResource)
    }
}

# Example: BrowserStack integration with CI/CD
name: Mobile Tests

on: [push, pull_request]

jobs:
  mobile-tests:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        platform: ['android', 'ios']

    steps:

      - uses: actions/checkout@v3

      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install dependencies
        run: npm install

      - name: Run tests on BrowserStack
        env:
          BROWSERSTACK_USERNAME: ${{ secrets.BROWSERSTACK_USERNAME }}
          BROWSERSTACK_ACCESS_KEY: ${{ secrets.BROWSERSTACK_ACCESS_KEY }}
        run: |
          npm run test:mobile:${{ matrix.platform }}

import 'package:flutter_test/flutter_test.dart';
import 'package:myapp/services/authentication_service.dart';

void main() {
  group('AuthenticationService', () {
    late AuthenticationService authService;

    setUp(() {
      authService = AuthenticationService();
    });

    test('validates email format correctly', () {
      expect(authService.isValidEmail('user@example.com'), true);
      expect(authService.isValidEmail('invalid-email'), false);
    });

    test('validates password strength', () {
      expect(authService.isStrongPassword('weak'), false);
      expect(authService.isStrongPassword('StrongP@ss123'), true);
    });
  });
}

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:myapp/widgets/login_form.dart';

void main() {
  testWidgets('LoginForm displays and validates input',
      (WidgetTester tester) async {
    await tester.pumpWidget(
      MaterialApp(home: Scaffold(body: LoginForm()))
    );

    // Find widgets
    final emailField = find.byKey(Key('email-field'));
    final passwordField = find.byKey(Key('password-field'));
    final loginButton = find.byKey(Key('login-button'));

    // Verify initial state
    expect(emailField, findsOneWidget);
    expect(passwordField, findsOneWidget);
    expect(loginButton, findsOneWidget);

    // Enter text
    await tester.enterText(emailField, 'user@example.com');
    await tester.enterText(passwordField, 'password123');
    await tester.pump();

    // Verify button is enabled
    final button = tester.widget<ElevatedButton>(loginButton);
    expect(button.enabled, true);

    // Tap login button
    await tester.tap(loginButton);
    await tester.pumpAndSettle();

    // Verify navigation or loading state
    expect(find.byType(CircularProgressIndicator), findsOneWidget);
  });
}

import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:myapp/main.dart' as app;

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('End-to-end login flow', () {
    testWidgets('Complete user journey', (tester) async {
      app.main();
      await tester.pumpAndSettle();

      // Navigate to login
      await tester.tap(find.text('Sign In'));
      await tester.pumpAndSettle();

      // Enter credentials
      await tester.enterText(
        find.byKey(Key('email-field')),
        'user@example.com'
      );
      await tester.enterText(
        find.byKey(Key('password-field')),
        'SecurePass123!'
      );

      // Submit login
      await tester.tap(find.byKey(Key('login-button')));
      await tester.pumpAndSettle(Duration(seconds: 5));

      // Verify successful login
      expect(find.text('Dashboard'), findsOneWidget);
      expect(find.text('Welcome back!'), findsOneWidget);
    });
  });
}

import React from 'react';
import { render, fireEvent, waitFor } from '@testing-library/react-native';
import LoginScreen from '../screens/LoginScreen';

describe('LoginScreen', () => {
  it('renders login form correctly', () => {
    const { getByTestId, getByText } = render(<LoginScreen />);

    expect(getByTestId('email-input')).toBeTruthy();
    expect(getByTestId('password-input')).toBeTruthy();
    expect(getByText('Sign In')).toBeTruthy();
  });

  it('validates email format', async () => {
    const { getByTestId, getByText } = render(<LoginScreen />);

    const emailInput = getByTestId('email-input');
    fireEvent.changeText(emailInput, 'invalid-email');

    const submitButton = getByText('Sign In');
    fireEvent.press(submitButton);

    await waitFor(() => {
      expect(getByText('Invalid email format')).toBeTruthy();
    });
  });

  it('calls onLogin with correct credentials', async () => {
    const mockOnLogin = jest.fn();
    const { getByTestId, getByText } = render(
      <LoginScreen onLogin={mockOnLogin} />
    );

    fireEvent.changeText(
      getByTestId('email-input'),
      'user@example.com'
    );
    fireEvent.changeText(
      getByTestId('password-input'),
      'SecurePass123!'
    );
    fireEvent.press(getByText('Sign In'));

    await waitFor(() => {
      expect(mockOnLogin).toHaveBeenCalledWith({
        email: 'user@example.com',
        password: 'SecurePass123!'
      });
    });
  });
});

describe('Login Flow', () => {
  beforeAll(async () => {
    await device.launchApp();
  });

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

  it('should login successfully with valid credentials', async () => {
    // Navigate to login screen
    await element(by.id('login-tab')).tap();

    // Enter credentials
    await element(by.id('email-input')).typeText('user@example.com');
    await element(by.id('password-input')).typeText('SecurePass123!');

    // Hide keyboard
    await element(by.id('password-input')).tapReturnKey();

    // Tap login button
    await element(by.id('login-button')).tap();

    // Wait for navigation
    await waitFor(element(by.id('dashboard-screen')))
      .toBeVisible()
      .withTimeout(5000);

    // Verify logged in state
    await expect(element(by.text('Welcome back!'))).toBeVisible();
  });

  it('should display error with invalid credentials', async () => {
    await element(by.id('email-input')).typeText('wrong@example.com');
    await element(by.id('password-input')).typeText('wrongpass');
    await element(by.id('login-button')).tap();

    await waitFor(element(by.text('Invalid credentials')))
      .toBeVisible()
      .withTimeout(3000);
  });

  it('should handle network errors gracefully', async () => {
    // Simulate offline mode
    await device.setURLBlacklist(['.*']);

    await element(by.id('email-input')).typeText('user@example.com');
    await element(by.id('password-input')).typeText('SecurePass123!');
    await element(by.id('login-button')).tap();

    await expect(element(by.text('Network error'))).toBeVisible();

    // Reset network
    await device.setURLBlacklist([]);
  });
});