Testing Mobile Apps

on iOS (and Android - with focus on testing different types of functionalities)

 * E-commerce flows,
 * user interface

I. Setting the Stage (Regardless of OS)

Understanding Requirements:

• The absolute foundation. What’s the app supposed to do?
• sources: user stories, design documents, specifications, and conversations with developers/product owners.
• Ambiguity kills testing efforts.

Test Environment Setup:

1. Real Devices (essential).
   • Implemented a range of devices with different screen sizes, OS versions (focus on the most popular and the minimum supported), and hardware specs.
   • Try a physical device lab (cloud-based, not so much first hand exprience with it).
   • At Google we built racks, at Amazon the developers sent prototypes within a cluster. (Sometimes a project has only one prototype.) * Emulators/Simulators (have not used on a regular basis): * Useful for initial testing and automation development. * Android Studio’s emulator for Android. * Xcode’s simulator for iOS.

> Note: never rely solely on emulators; they don’t perfectly replicate real-world device behavior.

1. Network Conditions: * Mimic different network speeds (Wi-Fi, 4G, 3G, Edge).
   • testing 5G phones (Google):
     • I didn’t build the entire lab,
     • monitoring the data and debugging, triaging the bug. * The developers used tools like Network Link Conditioner (macOS) or Android’s Developer Options to throttle bandwidth and simulate packet loss.
2. Background Apps: * Run common background apps (music streaming, email, location services) to simulate real-world memory pressure and potential conflicts.
   • Test Data: Prepared realistic and comprehensive test data. Used a small test database / API endpoint to avoid impacting production data.

Test Plan:

• Outlining my testing strategy, scope, objectives, timelines, and resource allocation. Here my Agile Test plan within my QA playbook
• With a feature that is already on prod (upgrading an existing feature) you plan differently compared to a feature that is new & added.

II. Key Testing Areas (Android & iOS, with Android Emphasis)

breakdown by functionality, with considerations for both platforms but tailored more towards Android:

A. Functionality (Core Logic)

• E-commerce Flows (Adding to Cart, Checkout, Payment Processing):
  • Android & iOS:
    • Happy Path: Successful order placement, payment processing, order confirmation.
    • Edge Cases:
      • Invalid input (e.g., incorrect credit card number, expiry date).
      • Insufficient funds.
      • Expired promo codes.
      • Item out of stock during checkout.
      • Address validation failures.
      • Connectivity issues during payment.
    • Error Handling: Graceful error messages and appropriate recovery actions. No crashes!
    • Security: (I have no experinece in this)
      • Encryption of sensitive data (credit card details).
      • Protection against MITM (Man-in-the-Middle) attacks.
      • Compliance with PCI DSS standards (if applicable).
    • Android Specific:
      • Test with different payment methods (Google Pay, etc.).
      • Handling different screen sizes and resolutions during the checkout flow.
• User Authentication (Login, Registration, Password Reset):
  • Android & iOS:
    • Valid/Invalid Credentials: Test with correct and incorrect usernames and passwords.
    • Password Complexity: Enforce and test password complexity rules.
    • Account Lockout: Test account lockout after multiple failed login attempts.
    • Two-Factor Authentication (2FA): Test 2FA setup and login flows.
    • Social Login (Google, Facebook): Test integration with social login providers.
    • Password Reset: Verify password reset functionality (email/SMS).
    • Session Management: Test session timeouts and handling of multiple active sessions.
  • Android Specific:
    • Test with different authentication methods (fingerprint, face unlock, oAuth).
• Data Synchronization (Cloud Sync, Offline Mode):
  • Android & iOS:
    • Initial Sync: Test the initial data synchronization process.
    • Incremental Sync: Verify that only new or changed data is synchronized.
    • Conflict Resolution: Test how the app handles data conflicts between local and cloud storage.
    • Offline Functionality: Test the app’s behavior when offline (e.g., can users still browse cached data?).
    • Background Sync: Verify that background synchronization works as expected.
  • Android Specific:
    • Test with different background data restrictions (battery saver mode, data saver mode).
• Push Notifications:
  • Android & iOS:
    • Delivery: Verify that notifications are delivered promptly and reliably.
    • Content: Check that the notification content is accurate and informative.
    • Actions: Test the actions associated with notifications (e.g., tapping a notification opens the app).
    • Notification Settings: Verify that users can customize notification settings.
    • Background Delivery: Test notification delivery when the app is in the background or closed.
  • Android Specific:
    • Test with different notification channels (Android 8.0+).
    • Verify that notifications are displayed correctly on different Android versions.

B. User Interface (UI) Testing

• Android & iOS:
  • Visual Layout:
    • Screen Size Compatibility: Test on various screen sizes and resolutions to ensure UI elements are properly sized and positioned.
    • Orientation Changes: Verify that the UI adapts correctly to portrait and landscape orientations.
    • Text Overflow: Prevent text from overflowing its containers.
    • Alignment and Spacing: Check for consistent alignment and spacing between UI elements.
  • Usability:
    • Intuitive Navigation: Ensure the app is easy to navigate.
    • Clear Labels and Instructions: Provide clear and concise labels and instructions.
    • Accessibility: Follow accessibility guidelines (e.g., provide alternative text for images, ensure sufficient color contrast). Use accessibility tools to verify compliance.
    • Responsiveness: The UI should respond quickly to user input.
  • Android & iOS (Different implementations):
    • Themeing (Light/Dark Mode): Verify that the app’s UI adapts correctly to different themes.
  • Android Specific:
    • Test with different display densities (dpi).
    • Test with different keyboard layouts.
    • Check for proper handling of Android UI components (e.g., Material Design components).

C. Performance Testing

• Android & iOS:
  • App Launch Time: Measure the time it takes for the app to launch.
  • Memory Usage: Monitor the app’s memory consumption.
  • CPU Usage: Track the app’s CPU usage.
  • Battery Consumption: Analyze the app’s battery drain.
  • Scrolling Performance: Ensure smooth scrolling in lists and other scrollable views.
  • Network Performance: Measure network latency and throughput.
• Tools: Android Studio Profiler, Xcode Instruments, third-party performance monitoring tools.

D. Network Connectivity Testing

• Android & iOS:
  • Connectivity Loss: Test how the app handles loss of network connectivity.
  • Network Switching: Verify that the app recovers gracefully from network switching (e.g., Wi-Fi to cellular).
  • Data Usage: Monitor the app’s data usage.
  • Proxy Settings: Test the app’s behavior with different proxy settings.
  • Secure Connections (HTTPS): Ensure that all network communication is encrypted using HTTPS.

E. Security Testing

• Android & iOS:
  • Data Storage: Verify that sensitive data is stored securely.
  • Code Security: Protect against code injection and other code-level vulnerabilities.
  • Permissions: Ensure that the app only requests necessary permissions.
  • Third-Party Libraries: Scan third-party libraries for known vulnerabilities.
  • Penetration Testing: Conduct penetration testing to identify security flaws.
• Tools: Static analysis tools, dynamic analysis tools, penetration testing tools.

F. Installation and Update Testing (Android Specific - iOS is more controlled)

• Android:
  • Installation from Different Sources: Google Play Store, APK files.
  • Update Process: Test the update process from different versions of the app.
  • Uninstall Process: Verify that the app is completely uninstalled.
  • Permissions During Installation/Update: Ensure proper handling of permission requests.
  • Storage Space: Verify that the app has sufficient storage space to install and run.
  • Android App Bundles: Test with Android App Bundles to ensure that the correct resources are delivered to different devices.

III. Testing Methodologies

• Manual Testing: Traditional hands-on testing.
• Test Party: Invite tester from other features for a one day hands-on testing of a specific feature.
• Automated Testing: Using tools and scripts to automate repetitive tasks. Crucial for regression testing. Frameworks: Appium, Espresso (Android), XCUITest (iOS).
• Exploratory Testing: Simultaneous learning, test design, and test execution. Good for uncovering unexpected issues.
• Beta Testing: Releasing the app to a limited group of users for feedback before the official launch.
• A/B Testing: Testing different versions of the app to see which performs better.

---