Appium Desired Capabilities For Cloud Testing



As of the 3rd quarter of 2023, the standard user worldwide spend on mobile applications per smartphone was approx. 5.05 USD, up by 4% from 4.86 USD spent on average by users during the 3rd quarter of 2022. Between the 1st and the 3rd quarter of 2022, users spending on mobile applications experienced a downward trend with small fluctuations.


The mobile app market is extremely competitive. To stand out and retain consumers, your mobile application must be bug-free and provide a flawless experience. Hence, before publishing your application on diverse platforms like the Google Play Store or Apple App Store, it should meet precise performance and quality standards. Testing ensures that your mobile application is approved and reaches a broader audience. Testing chiefly helps in detecting and addressing flaws such as crashes, slow loading times, or unresponsive user interfaces.

Among various other mobile app testing tools, Appium, an open-source tool, has gained huge popularity. When combined with cloud-centric testing platforms like LambdaTest, it offers a robust solution for testing across an extensive suite of mobile devices.

What is Appium?

It is a cross-platform mobile automation test tool that allows the convenient generation of automated test cases for Android and iOS platforms. It can mimic multiple factions within an application, such as text input, swiping, and clicking, accomplishing any activities that would usually need manual intervention.

Appium Architecture

Initially, Desired Capabilities assisted us in configuring the Appium server. It also provides the standards by which we wish to execute our automated script. Appium server also accepts HTTP requests encoded in JSON format from the customer libraries. Such requests are then managed in distinct ways, contingent on the platform on which it is running.

For instance, one could request the environment (real device or emulator), which version of the OS to execute the test on, and more. Desired Capabilities are key/important pairs in JSON format and are sent to the Appium Server by the Appium user when a fresh new automated session is requested.

It follows the Consumer-Server Architecture. There are three crucial sections encompassed in it:

  1. Appium Server
  2. Appium Client
  3. End device

What Are Desired Capabilities All about?

‘Desired Capabilities’ assists us in changing the server behavior while Automation. In Appium, it is a kind of key-value pair or hashmap, utilized to direct a command to the APPIUM server. In APPIUM, all the user commands are implemented in the session context.

Where do we utilize Desired Capabilities?

We utilize DesireCapabilities when we generate the session via-

  • Eclipse IDE or IntelliJ IDEA
  • Appium Inspector

Understanding Appium Desired Capabilities

It is a series of key-value pairs that state the behavior of an automation session. They play a critical role in the configuration of how an Appium server could execute automated testing. By stating these capabilities, you can define the platform, target a definite emulator or mobile device, and fix other parameters.

To make the most of such capabilities, consider the following:

  1. Platform Version: State the Operating System version.
  2. Platform Name: Direct whether you are testing on iOS or Android.
  3. Automation Name: Choose ‘XCUITest’ for iOS or ‘UiAutomator2’ for Android.
  4. Device Name: Set the name of the emulator or mobile device.
  5. Browser Name: If you are testing web apps, state the browser name.
  6. App: Give the path to the app’s .ipa (iOS) or.apk (Android) file.

There are several capabilities that Appium supports; consequently, we can classify the Capabilities into 3 sections:

  • General Capabilities.
  • iOS Capabilities.
  • Android Capabilities.

Crucial details to consider While configuring Desired Capabilities are as follows:

  1. platformName: Represents the platform name being used, such as Android, iOS, or FirefoxOS.
  2. automationName: States the automation engine to utilize, either Selendroid or Appium (default).
  3. platformVersion: Refers to the version no. of the mobile device’s OS, for instance, 4.4 or 7.1.
  4. deviceName: States the device name. For Android, this can be the name of the arbitrary. For iOS, it can be acquired using the “instruments -s devices” command.
  5. udid: Gives an exceptional identifier for the linked physical device, which can be acquired using the “adb devices” command.
  6. app: Represents the absolute path (local) or a remote HTTP URL indicating an installation package (.zip, .ipa, or .apk, file). Appium installs this set on a suitable device. For Android, this parameter isn’t needed if the appActivity and appPackage parameters are given. This parameter isn’t compatible with browserName. (Frequently used collectively with the noSign property.)  
  7. browserName: States the H5 browser to be tested. If testing an application, this could be ignored.
  8. newCommandTimeout: Signifies the time (in a sec) that Appium waits for the customer to send a fresh command before leaving or ending the session.
  9. noReset: When set to true, it prevents the application’s state from being retune before the present session. By default, it is series to false.
  10. fullReset: (iOS) Removes all simulator folders. (Android) To clear the application’s information, the application should be uninstalled to attain the reset effect. In Android, the application is also uninstalled after the session is finished. The default worth is false.

Specific to Android, The Following Added Key-Value Pairs Are Normally Used:

  1. appActivity: Refers to the Activity name to be released from the application package. Generally, it requires to be prefixed with a dot (‘.’). While testing an H5 page, this property could be ignored.
  2. appPackage: Defines the Android app’s package name to be implemented. If testing an H5 page, this property could be ignored.
  3. resetKeyboard: After utilizing the Unicode keyboard in a Unicode testing, this property, when fixed to true, restores the input method to its initial state. If used independently, the activity could be ignored. The default setting is false.
  4. unicodeKeyboard: When set to true, it enables the use of the Unicode input method. The default value is false.
  5. noSign: When employed to true, it skips the inspecting and debugging signature steps for the particular app. The feature applies to UiAutomator and does not apply to Selendroid. By default, the setting value is false. (Normally used in conjunction with the ‘app’ property.)

Example of utilizing Appium desired capabilities in a Python script for mobile app test. Let’s see how to build the Desired Capabilities for Android application tests using Appium.

Before preceding firstly confirm that you have Appium and the essential dependencies installed and that your Android emulator or real-time gadget is linked.

from appium import webdriver

# Define the Desired Capabilities

desired_capabilities = {

    “platformName”: “Android”,

    “platformVersion”: “your_android_version”,

    “deviceName”: “your_device_name_or_emulator_name”,

    “app”: “path_to_your_apk_file.apk”, # Replace with the actual path

    “automationName”: “UiAutomator2”,

    “appPackage”: “”, # Replace with your app’s package name

    “appActivity”: “” # Replace with your app’s main activity


# Initialize the Appium driver

driver = webdriver.Remote(“http://localhost:4723/wd/hub”, desired_capabilities)

# Perform test actions

element = driver.find_element_by_id(“element_id”)

# Close the driver


In this illustrative example:

  1. desired_capabilities explain the crucial-value pairs for the competencies you wish to set. Be sure to substitute “your_device_name_or_emulator_name”, “your_android_version”, “”, “”, and “path_to_your_apk_file.apk”, with the real values connected to your Android application.
  2. The Appium driver is initialized by using the webdriver.Remote method, with the Appium server URL & desired capabilities given as arguments.
  3. Subsequently, you can then execute test actions, including tasks like finding components and engaging with them.
  4. Lastly, don’t forget to close the driver by utilizing the “driver.quit()” method, to release the valuable resources.

This is a simple case of how to set up Appium Desired Capabilities for app (android) testing. You can additionally adapt and expand this test script to meet your particular testing requirements & use cases. Besides, when incorporating AI-powered test orchestration and test execution platforms such as LambdaTest, you can specify the server URL in the cloud to run testing on real-time devices hosted within the cloud environment.

Advantages Of Employing Appium Desired Capabilities in Cloud Testing:

  1. Custom Test Environments: Capabilities let you adjust and fine-tune the testing environment, confirming it exactly matches your necessities.
  2. Cross-Platform Testing: Appium Desired Capabilities empower you to craft tests just once and implement them across multiple platforms, saving extra effort and time.
  3. Parallel Testing: Through the configuration of competencies for varied devices and versions, you can run parallel testing, notably decreasing the time required for test implementation.
  4. Real-World Testing: Capabilities allow you to target real-time mobile gadgets hosted in a cloud-centric mobile device lab, delivering a real-world test experience.
  5. Automated Script Execution: Desired Capabilities can be utilized to automate the execution of test scripts across a diverse set of browsers, devices, and OSs (operating systems).
  6. Streamlined Integration: Integrating Capabilities with cloud testing platforms can streamline the course of configuring and executing testing across a diverse array of devices and browsers.

Presenting LambdaTest – Your Dynamic Mobile Device Lab

LambdaTest is an AI-powered test orchestration and test execution platform that proposes a massive selection of real-time mobile devices for app testing. With this pristine platform, you can flawlessly incorporate Desired Capabilities into the test scripts and implement them across an array of browsers and devices, all from your web browser. Here is why this could-based platform stands out:

  • Scalability: Effortlessly scale your testing to cover a wide range of OS versions, devices, & browsers.
  • Real Device Lab: Access a broad library of real-time devices, counting iOS and Android tablets and smartphones.
  • Geo-location Testing: Test your application’s geolocation traits on real-time devices from different locations.
  • Parallel Testing: Execute Appium scripts simultaneously on various devices, decreasing test implementation time.
  • Smooth Integration: LambdaTest flawlessly incorporates Appium, letting you utilize Desired Capabilities to target particular browsers and devices.

In a nutshell, using Appium Desired Capabilities in combination with a mobile device lab such as LambdaTest can streamline your app testing process. It allows you to perform testing across various real devices, saving extra effort and guaranteeing the mobile application quality. LambdaTest’s cloud-based approach and vast device library make it a game-changer for mobile application testing.

Unleash the power of LambdaTest and Appium Desired Capabilities to take your mobile app testing to the next height.  

Frequently Asked Questions (FAQs)

1. Why are Desired Capabilities significant in mobile app testing?

Capabilities let QA specialists specify the precise conditions for successively implementing automation testing, making it possible to target particular platforms, devices, and application configurations. This particular customization is vital for attaining accurate and effective testing.

2. What is the process to set up Appium Desired Capabilities for cloud-based testing?

You can set up Capabilities by defining main-value pairs based on your testing necessities, like app, device, platform, and automation name. Such capabilities can be utilized in Appium test scripts to configure the test environment.

3. What are the benefits of parallel testing with Appium Desired Capabilities?

Parallel testing lets you execute test scripts simultaneously on various devices, considerably reducing test implementation time. This is specifically helpful when you necessitate testing your app across an extensive suite of devices.

4. How does cloud-based testing with platforms such as LambdaTest improve mobile app testing?

Such platforms offer access to a distinct suite of real-time browsers and devices, letting you create a real-time test environment. This confirms that your application functions properly across diverse locations and configurations.


Exit mobile version