git clone https://github.com/JasonTeixeira/Mobile-Testing-Framework
# See repo README for setup
# Typical patterns:
# - npm test / npm run test
# - pytest -q
# - make test

Built a cross-platform mobile testing framework using Appium and Python that automated testing for iOS and Android apps from a single codebase. Reduced mobile regression testing from 2 days to 2 hours (96% faster) while supporting 15+ device/OS combinations, catching 23 device-specific bugs before production.

• Regression time measured as end-to-end suite duration across target device matrix.
• Device coverage tracked by executed capability matrix (iOS/Android versions).
• Bugs counted from pre-release device-specific failures caught by automation.

When I joined the e-commerce startup, they were launching mobile apps for iOS and Android. The development team had built a React Native app that needed to run flawlessly on:

iOS Devices:

• iPhone 15 Pro (iOS 17)
• iPhone 14 (iOS 16)
• iPhone SE (iOS 15)
• iPad Pro (iOS 17)
• iPad Air (iOS 16)

Android Devices:

• Samsung Galaxy S23 (Android 14)
• Google Pixel 8 (Android 14)
• Samsung Galaxy A54 (Android 13)
• OnePlus 11 (Android 13)
• Budget devices (various manufacturers)

Critical Flows:

• User registration and login
• Product browsing and search
• Add to cart and checkout
• Payment processing (credit card, PayPal, Apple Pay, Google Pay)
• Order tracking
• Push notifications
• Offline mode

Manual testing across devices was a nightmare:

• 2 days per release - QA manually testing on physical devices
• Limited device coverage - Only had 5 physical devices
• Inconsistent results - Different testers, different interpretations
• Device-specific bugs - Features working on iOS, broken on Android
• Screen size issues - UI breaking on small/large screens
• OS version problems - New iOS release, app crashes
• No automation - Everything done manually
• Payment testing - Scared to test real transactions
• Push notifications - Hard to test reliably
• Regression pain - Re-test everything on every device

The manual testing bottleneck was costly:

• 2-week release cycles - Mostly waiting for QA
• Production bugs - 23 device-specific issues in 3 months
• Customer churn - 8% citing app crashes
• Support costs - 35% of tickets were mobile app issues
• App store ratings - Dropped to 3.2 stars
• Revenue loss - $400K/year from cart abandonment
• Developer frustration - "Works on my iPhone" syndrome
• Competitive disadvantage - Competitors shipping faster

The team had tried various approaches:

• Manual testing only - Slow, expensive, inconsistent
• Simulators/Emulators - Missed real device issues
• Cloud device farms - Expensive ($2K/month), high latency
• Recording tools - Brittle tests that broke constantly
• Platform-specific tools - XCUITest for iOS, Espresso for Android (2 codebases)

We needed cross-platform automation that worked on real devices.

I designed a unified mobile testing framework with these principles:

1. Cross-Platform - Single codebase for iOS and Android
2. Page Object Model - Reusable, maintainable test structure
3. Real Device Testing - Cloud device farm integration
4. Parallel Execution - Run tests on multiple devices simultaneously
5. Visual Validation - Screenshot comparison for UI regression
6. Offline Testing - Test app behavior without network

This provided:

• Unified codebase - One test suite, two platforms
• Comprehensive coverage - 15+ device combinations
• Fast execution - Parallel tests complete in 2 hours
• Reliable results - Consistent, repeatable automation

Why Appium?

• Cross-platform support (iOS + Android + Web)
• Uses native automation frameworks (XCUITest, UIAutomator2)
• Open source and community-supported
• Supports real devices and emulators
• Works with multiple languages (we chose Python)

Why Python?

• Team's primary language
• Great Appium client library
• Rich ecosystem (pytest, Pillow for screenshots)
• Easy to learn and maintain

Why BrowserStack/AWS Device Farm?

• Access to 1000+ real devices
• No device maintenance overhead
• Parallel test execution
• Automated screenshots and logs
• Cost-effective ($500/month vs buying devices)

Why pytest?

• Powerful fixture system
• Parametrized tests for multiple devices
• Great reporting
• Parallel execution with pytest-xdist

┌─────────────────────────────────────────────┐
│         Test Suite (pytest)                 │
│  - test_login.py                            │
│  - test_checkout.py                         │
│  - test_search.py                           │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│      Page Objects (Business Logic)          │
│  - LoginPage, CheckoutPage, SearchPage      │
│  - Cross-platform locator strategy          │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│         Base Page (Common Actions)          │
│  - tap(), swipe(), scroll()                 │
│  - wait_for_element()                       │
│  - screenshot(), get_text()                 │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│         Appium Driver Layer                 │
│  - iOS: XCUITest automation                 │
│  - Android: UIAutomator2                    │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│         Cloud Device Farm                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ iPhone   │  │ Galaxy   │  │  Pixel   │  │
│  │   15     │  │   S23    │  │    8     │  │
│  └──────────┘  └──────────┘  └──────────┘  │
└─────────────────────────────────────────────┘

# base_page.py
from appium import webdriver
from appium.webdriver.common.appiumby import AppiumBy
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import platform

class BasePage:
    """Base page with cross-platform mobile automation"""
    
    def __init__(self, driver):
        self.driver = driver
        self.wait = WebDriverWait(driver, 15)
    
    def find_element(self, locator):
        """Find element with explicit wait"""
        return self.wait.until(
            EC.presence_of_element_located(locator)
        )
    
    def tap(self, locator):
        """Tap element (cross-platform click)"""
        element = self.wait.until(
            EC.element_to_be_clickable(locator)
        )
        element.click()
    
    def send_keys(self, locator, text):
        """Type text into element"""
        element = self.find_element(locator)
        element.clear()
        element.send_keys(text)
    
    def get_text(self, locator):
        """Get element text"""
        return self.find_element(locator).text
    
    def swipe_up(self, distance=0.8):
        """Swipe up on screen"""
        size = self.driver.get_window_size()
        start_x = size['width'] // 2
        start_y = int(size['height'] * distance)
        end_y = int(size['height'] * (1 - distance))
        
        self.driver.swipe(start_x, start_y, start_x, end_y, duration=800)
    
    def swipe_down(self, distance=0.8):
        """Swipe down on screen"""
        size = self.driver.get_window_size()
        start_x = size['width'] // 2
        start_y = int(size['height'] * (1 - distance))
        end_y = int(size['height'] * distance)
        
        self.driver.swipe(start_x, start_y, start_x, end_y, duration=800)
    
    def scroll_to_element(self, text):
        """Scroll until element is visible"""
        if self.is_ios():
            # iOS: Use predicateString
            locator = (AppiumBy.IOS_PREDICATE, f'label == "{text}"')
        else:
            # Android: Use UiScrollable
            locator = (
                AppiumBy.ANDROID_UIAUTOMATOR,
                f'new UiScrollable(new UiSelector().scrollable(true))'
                f'.scrollIntoView(new UiSelector().text("{text}"))'
            )
        
        return self.find_element(locator)
    
    def is_ios(self):
        """Check if running on iOS"""
        return self.driver.capabilities['platformName'].lower() == 'ios'
    
    def is_android(self):
        """Check if running on Android"""
        return self.driver.capabilities['platformName'].lower() == 'android'
    
    def hide_keyboard(self):
        """Hide the keyboard"""
        try:
            if self.is_ios():
                self.driver.find_element(AppiumBy.NAME, "Done").click()
            else:
                self.driver.hide_keyboard()
        except:
            pass  # Keyboard not showing
    
    def take_screenshot(self, name):
        """Take screenshot for visual verification"""
        self.driver.save_screenshot(f"screenshots/{name}.png")

# pages/login_page.py
from appium.webdriver.common.appiumby import AppiumBy
from base_page import BasePage

class LoginPage(BasePage):
    """Login page with cross-platform locators"""
    
    def __init__(self, driver):
        super().__init__(driver)
        
        # Platform-specific locators
        if self.is_ios():
            self.email_input = (AppiumBy.ACCESSIBILITY_ID, "email-input")
            self.password_input = (AppiumBy.ACCESSIBILITY_ID, "password-input")
            self.login_button = (AppiumBy.ACCESSIBILITY_ID, "login-button")
            self.error_message = (AppiumBy.ACCESSIBILITY_ID, "error-message")
        else:  # Android
            self.email_input = (AppiumBy.ID, "com.myapp:id/email")
            self.password_input = (AppiumBy.ID, "com.myapp:id/password")
            self.login_button = (AppiumBy.ID, "com.myapp:id/login_btn")
            self.error_message = (AppiumBy.ID, "com.myapp:id/error")
    
    def login(self, email, password):
        """Perform login"""
        self.send_keys(self.email_input, email)
        self.send_keys(self.password_input, password)
        self.hide_keyboard()
        self.tap(self.login_button)
    
    def get_error_message(self):
        """Get error message text"""
        return self.get_text(self.error_message)
    
    def is_logged_in(self):
        """Check if login was successful"""
        # Wait for dashboard to appear
        if self.is_ios():
            dashboard = (AppiumBy.ACCESSIBILITY_ID, "dashboard")
        else:
            dashboard = (AppiumBy.ID, "com.myapp:id/dashboard")
        
        try:
            self.find_element(dashboard)
            return True
        except:
            return False

class CheckoutPage(BasePage):
    """Checkout page for purchase flow"""
    
    def __init__(self, driver):
        super().__init__(driver)
        
        if self.is_ios():
            self.add_to_cart_btn = (AppiumBy.ACCESSIBILITY_ID, "add-to-cart")
            self.cart_icon = (AppiumBy.ACCESSIBILITY_ID, "cart-icon")
            self.checkout_btn = (AppiumBy.ACCESSIBILITY_ID, "checkout-button")
            self.card_number = (AppiumBy.ACCESSIBILITY_ID, "card-number")
            self.expiry_date = (AppiumBy.ACCESSIBILITY_ID, "expiry-date")
            self.cvv = (AppiumBy.ACCESSIBILITY_ID, "cvv")
            self.place_order_btn = (AppiumBy.ACCESSIBILITY_ID, "place-order")
        else:
            self.add_to_cart_btn = (AppiumBy.ID, "com.myapp:id/add_cart")
            self.cart_icon = (AppiumBy.ID, "com.myapp:id/cart")
            self.checkout_btn = (AppiumBy.ID, "com.myapp:id/checkout")
            self.card_number = (AppiumBy.ID, "com.myapp:id/card_num")
            self.expiry_date = (AppiumBy.ID, "com.myapp:id/expiry")
            self.cvv = (AppiumBy.ID, "com.myapp:id/cvv")
            self.place_order_btn = (AppiumBy.ID, "com.myapp:id/place_order")
    
    def add_item_to_cart(self):
        """Add item to shopping cart"""
        self.tap(self.add_to_cart_btn)
    
    def go_to_cart(self):
        """Navigate to cart"""
        self.tap(self.cart_icon)
    
    def proceed_to_checkout(self):
        """Start checkout process"""
        self.tap(self.checkout_btn)
    
    def enter_payment_details(self, card_num, expiry, cvv_code):
        """Fill payment information"""
        self.send_keys(self.card_number, card_num)
        self.send_keys(self.expiry_date, expiry)
        self.send_keys(self.cvv, cvv_code)
        self.hide_keyboard()
    
    def place_order(self):
        """Complete the purchase"""
        self.tap(self.place_order_btn)

# config/devices.py
"""Device configurations for testing"""

IOS_DEVICES = [
    {
        "platformName": "iOS",
        "platformVersion": "17.0",
        "deviceName": "iPhone 15 Pro",
        "app": "path/to/app.ipa",
        "automationName": "XCUITest",
        "udid": "auto"
    },
    {
        "platformName": "iOS",
        "platformVersion": "16.0",
        "deviceName": "iPhone 14",
        "app": "path/to/app.ipa",
        "automationName": "XCUITest"
    },
    {
        "platformName": "iOS",
        "platformVersion": "17.0",
        "deviceName": "iPad Pro",
        "app": "path/to/app.ipa",
        "automationName": "XCUITest"
    }
]

ANDROID_DEVICES = [
    {
        "platformName": "Android",
        "platformVersion": "14",
        "deviceName": "Samsung Galaxy S23",
        "app": "path/to/app.apk",
        "automationName": "UIAutomator2",
        "appPackage": "com.myapp",
        "appActivity": ".MainActivity"
    },
    {
        "platformName": "Android",
        "platformVersion": "14",
        "deviceName": "Google Pixel 8",
        "app": "path/to/app.apk",
        "automationName": "UIAutomator2",
        "appPackage": "com.myapp",
        "appActivity": ".MainActivity"
    },
    {
        "platformName": "Android",
        "platformVersion": "13",
        "deviceName": "Samsung Galaxy A54",
        "app": "path/to/app.apk",
        "automationName": "UIAutomator2",
        "appPackage": "com.myapp",
        "appActivity": ".MainActivity"
    }
]

# BrowserStack cloud devices
BROWSERSTACK_CONFIG = {
    "userName": "YOUR_USERNAME",
    "accessKey": "YOUR_ACCESS_KEY",
    "build": "Mobile App Test Build",
    "project": "E-Commerce App",
    "debug": True,
    "networkLogs": True,
    "visual": True
}

# tests/test_login.py
import pytest
from appium import webdriver
from pages.login_page import LoginPage
from config.devices import IOS_DEVICES, ANDROID_DEVICES

ALL_DEVICES = IOS_DEVICES + ANDROID_DEVICES

@pytest.fixture(params=ALL_DEVICES)
def mobile_driver(request):
    """Create Appium driver for each device"""
    capabilities = request.param
    driver = webdriver.Remote(
        command_executor='http://localhost:4723',
        desired_capabilities=capabilities
    )
    driver.implicitly_wait(10)
    yield driver
    driver.quit()

def test_successful_login(mobile_driver):
    """Test login with valid credentials"""
    login_page = LoginPage(mobile_driver)
    login_page.login("test@example.com", "password123")
    
    assert login_page.is_logged_in(), "Login failed"

@pytest.mark.parametrize("email,password,expected_error", [
    ("", "password", "Email is required"),
    ("test@example.com", "", "Password is required"),
    ("invalid", "password", "Invalid email format"),
    ("wrong@email.com", "wrong", "Invalid credentials")
])
def test_login_validation(mobile_driver, email, password, expected_error):
    """Test login validation errors"""
    login_page = LoginPage(mobile_driver)
    login_page.login(email, password)
    
    error = login_page.get_error_message()
    assert expected_error in error

# tests/test_checkout.py
def test_complete_purchase_flow(mobile_driver):
    """Test end-to-end purchase"""
    # Login first
    login_page = LoginPage(mobile_driver)
    login_page.login("test@example.com", "password123")
    
    # Navigate to product and add to cart
    checkout = CheckoutPage(mobile_driver)
    checkout.add_item_to_cart()
    checkout.go_to_cart()
    checkout.proceed_to_checkout()
    
    # Enter payment and complete
    checkout.enter_payment_details("4111111111111111", "12/25", "123")
    checkout.place_order()
    
    # Verify order confirmation
    # (additional assertions here)

# conftest.py - BrowserStack integration
import pytest
from appium import webdriver

BROWSERSTACK_HUB = "https://hub-cloud.browserstack.com/wd/hub"

@pytest.fixture(scope="function")
def browserstack_driver(request):
    """Run tests on BrowserStack cloud devices"""
    
    # Get device config from marker
    device_config = request.node.get_closest_marker("device").args[0]
    
    # Merge with BrowserStack config
    capabilities = {
        **device_config,
        "bstack:options": {
            "userName": "YOUR_USERNAME",
            "accessKey": "YOUR_KEY",
            "projectName": "Mobile App Tests",
            "buildName": f"Build {datetime.now().strftime('%Y%m%d_%H%M')}",
            "sessionName": request.node.name,
            "debug": True,
            "networkLogs": True
        }
    }
    
    driver = webdriver.Remote(
        command_executor=BROWSERSTACK_HUB,
        desired_capabilities=capabilities
    )
    
    yield driver
    
    # Mark test status in BrowserStack
    status = "passed" if not request.node.rep_call.failed else "failed"
    driver.execute_script(
        f'browserstack_executor: {{"action": "setSessionStatus", '
        f'"arguments": {{"status":"{status}"}}}}'
    )
    
    driver.quit()

# Run tests in parallel on BrowserStack
pytest tests/ \
    --browserstack \
    -n 5 \
    --dist loadgroup \
    --html=report.html

Speed Improvements:

• Regression testing: 2 days → 2 hours (96% faster)
• Test execution per device: 4 hours → 20 minutes (parallel)
• Test creation time: 3 days → 1 day (reusable page objects)
• Feedback loop: Next day → 2 hours (faster deployments)

Coverage Improvements:

• Device combinations tested: 5 → 15 (3x increase)
• Test scenarios: 30 manual → 150 automated
• Code coverage: 40% → 85% of mobile features
• Regression coverage: 60% → 95% of critical flows

Quality Improvements:

• Device-specific bugs found: 23 in 3 months (pre-release)
• Production bugs: 15/month → 2/month (87% reduction)
• Crash rate: 3.2% → 0.4% (88% improvement)
• App store rating: 3.2 → 4.6 stars (+1.4 points)

Business Impact:

• Release frequency: 2 weeks → 1 week (2x faster)
• Cart abandonment: $400K → $150K ($250K saved)
• Support tickets: -60% (mobile app issues)
• QA team size: Same (3 people), 10x more coverage

Critical Device-Specific Issues Caught:

1. Payment crash on Android 13 - App crashed during checkout on Samsung devices
2. Login failure on iPad - Landscape orientation broke layout
3. Push notification bug - Not working on OnePlus phones
4. Search broken on small screens - UI elements overlapping
5. Offline mode data loss - Cart cleared when network lost
6. Deep linking broken - Links from emails didn't work on Android
7. Gesture conflicts - Swipe interfered with carousel on iOS

"This framework transformed our mobile QA. We went from praying nothing breaks to confidently shipping every week." — VP of Engineering

"Finding that payment crash on Samsung devices before launch saved us from a PR disaster. Automated testing is a game changer." — Product Manager

"Our app rating jumped from 3.2 to 4.6 stars. Customers are noticing the quality improvements." — Customer Success Lead

1. Cross-platform from day 1 - Single codebase saved months of maintenance
2. Page Object Model - Made tests readable and maintainable
3. Cloud device farm - No device management overhead
4. Parallel execution - Cut execution time by 90%
5. Visual testing - Screenshot comparison caught UI regressions

1. Start with fewer devices - 15 was overwhelming initially
2. Better test data management - Hard-coded data became a problem
3. More unit tests for page objects - Would catch framework bugs faster
4. Earlier accessibility testing - Should have included from start
5. Performance benchmarks - App speed varied across devices

1. Cross-platform saves time - One codebase, two platforms
2. Real devices matter - Emulators miss critical issues
3. Parallel execution is essential - Linear execution doesn't scale
4. Page Objects are worth it - Makes tests maintainable long-term
5. Automate regression, explore manually - Best of both worlds

• Add visual regression testing (Percy/Applitools)
• Implement accessibility testing (axe-mobile)
• Add performance monitoring
• Test biometric authentication (Face ID, Fingerprint)
• Add network condition simulation (3G, offline)

• Push notifications testing is still partially manual
• Deep linking tests are brittle
• Camera/photo upload not fully automated
• In-app purchase testing limited

Core Technologies:

• Appium 2.0+
• Python 3.9+
• pytest 7.x
• Selenium WebDriver

Mobile Platforms:

• iOS: XCUITest automation
• Android: UIAutomator2

Cloud Services:

• BrowserStack Real Device Cloud
• AWS Device Farm (backup)

Supporting Tools:

• pytest-xdist (parallel execution)
• Pillow (screenshot comparison)
• Allure (reporting)

• Mobile Testing Best Practices
• Cross-Platform Automation with Appium

• Selenium Python Framework
• CI/CD Testing Pipeline

---

This framework is documented with setup guides and examples.

GitHub Repository: Mobile-Testing-Framework

---

Impressed by this project? I'm available for:

• Full-time Mobile QA roles
• Consulting engagements
• Framework architecture reviews
• Team training

Get in Touch | View Resume | More Projects