Understanding the UIAutomator Tool - Notes By ShariqSP

Understanding the UIAutomator Tool

UIAutomator is a testing framework provided by Google for automating user interface testing of Android applications. It enables developers and testers to write robust and reliable tests that can interact with the user interface of Android apps and system components, such as settings, notifications, and more.

Key Features of UIAutomator

System-Level Testing: Allows testing interactions across multiple apps and system components.
Cross-App Testing: Provides the ability to test scenarios that involve interactions with other apps.
Powerful UI Selector: Offers methods to locate UI components based on properties like text, description, resource ID, etc.
Backward Compatibility: Supports testing on Android devices with API levels 18 and above.
UIAutomator Viewer: A graphical tool to inspect the UI hierarchy and properties of Android apps.

UIAutomator Architecture

The framework consists of the following components:

Test Cases: Written in Java using the UIAutomator APIs.
UIAutomator Framework: Provides APIs to interact with UI elements and system components.
Android Debug Bridge (ADB): Facilitates communication between the development machine and the Android device.

1. Install UIAutomator2 via Appium

UIAutomator2 is the default driver for Android automation in Appium. Follow these steps to install and configure it:

Ensure that Appium is installed on your machine. If not, install it globally:
```
npm install -g appium
```
Install the UIAutomator2 driver:
```
appium driver install uiautomator2
```
Verify the installation by listing the installed drivers:
```
appium driver list
```
Start the Appium server:
```
appium
```

Set the desired capabilities in your test script to use the UIAutomator2 driver. Example:

        {
          "platformName": "Android",
          "deviceName": "emulator-5554",
          "app": "/path/to/app.apk",
          "automationName": "UiAutomator2"
        }

Run your test script using your preferred language bindings (e.g., Java, Python, etc.).

Installation and Setup

Follow these steps to set up UIAutomator for Android testing:

1. Prerequisites

Ensure you have Java Development Kit (JDK) installed on your system.
Install Android Studio with the Android SDK.
Connect an Android device with USB debugging enabled or set up an emulator.

2. Install UIAutomator Viewer

The UIAutomator Viewer is part of the Android SDK tools and is used to inspect the UI hierarchy of an app.

Open Android Studio and navigate to SDK Manager.
Ensure the SDK Tools tab has Android SDK Build-Tools installed.
Locate the UIAutomator Viewer tool in the `/tools/bin/` directory.

3. Write and Run Tests

Create a new Java project in your preferred IDE (e.g., IntelliJ IDEA or Eclipse).

Add the UIAutomator jar file to your project:

        /platforms/android-<API Level>/uiautomator.jar

Write test cases using the UIAutomator APIs. Example:

        import androidx.test.uiautomator.UiDevice;
        import androidx.test.uiautomator.UiSelector;

        public class MyTest {
          public static void main(String[] args) {
            UiDevice device = UiDevice.getInstance();
            device.findObject(new UiSelector().text("Settings")).click();
          }
        }

Compile and execute the tests using ADB:

        adb shell uiautomator runtest MyTest.jar -c MyTest

4. Inspect App UI

Launch the UIAutomator Viewer to inspect the application's UI hierarchy and obtain properties like text, resource ID, or class name:

Navigate to the `/tools/bin/` directory.
Run the command:
```
        uiautomatorviewer
      
```
Use the tool to capture a snapshot of the app's current UI for analysis.

Advantages of UIAutomator

Comprehensive system-level testing capabilities.
Works with real devices and emulators.
Supports testing across multiple apps and system components.

Limitations

Requires Java programming knowledge.
Cannot interact with WebView elements (requires Appium for hybrid apps).

With UIAutomator, you can create robust and reliable automation scripts for Android apps, making it a powerful tool for comprehensive testing scenarios.