How to write Appium testing code-your complete guide 2023-24

Appium is an open-source automation tool that allows you to write scripts to test mobile applications on different platforms such as Android and iOS. With Appium, you can automate the testing process, ensuring that your mobile app functions as intended across various devices and operating systems.

Overview of Appium Testing

Appium testing is a popular choice among developers and testers due to its flexibility and ease of use. It supports multiple programming languages, including Java, Python, Ruby, and C#, making it accessible to a wide range of developers.

Appium works by interacting with the application under test, just like a real user would. It uses the WebDriver protocol to communicate with the mobile device or emulator, allowing you to perform actions such as tapping buttons, entering text, and swiping gestures.

One of the key advantages of Appium is its cross-platform support. It allows you to write a single test script that can be executed on both Android and iOS devices, saving time and effort. This cross-platform capability makes Appium a valuable tool for organizations that develop mobile applications for multiple platforms.

Supported Platforms (Android and iOS)

Appium supports both Android and iOS platforms, making it a versatile choice for mobile app testing.

Android Testing

When it comes to testing Android applications with Appium, you can write your test scripts using any programming language that Appium supports. You can use popular frameworks such as JUnit or TestNG to structure your tests and make assertions about the behavior of your app.

To automate Android testing, you need to set up the necessary tools and dependencies. This includes installing the Android SDK, setting up the Android Virtual Device (AVD) emulator, and configuring the Appium server.

Once the setup is complete, you can start writing your test scripts. Appium provides a wide range of APIs and methods that allow you to interact with the Android application under test. You can perform actions like tapping buttons, entering text, verifying text content, and validating UI elements.

iOS Testing

Appium also supports testing iOS applications, allowing you to write test scripts using the same programming languages and frameworks as Android testing.

To automate iOS testing, you need to set up the necessary tools and dependencies. This includes installing Xcode, which includes the necessary iOS simulator for testing. You also need to configure the Appium server and set up the desired capabilities for your iOS device.

Once the setup is complete, you can start writing your test scripts. Appium provides APIs and methods specifically designed for iOS testing. You can interact with UI elements, perform gestures, validate text content, and navigate through different screens of your iOS application.

How to Find App Package and Activity in Android

To write effective scripts in Appium testing, it is crucial to identify the app package and activity of the Android application you want to automate. The app package represents the unique identifier of the application, while the activity refers to the specific screen or functionality within the app. In this section, we will explore the steps to find the app package and activity in Android, along with the commands for both Windows and Mac/Linux platforms.

Steps to Find App Package and Activity

1. Enable Developer Options: Before proceeding, ensure that the Developer Options are enabled on your Android device. To do this, go to the device settings, scroll down to the “About phone” section, and tap on the “Build number” multiple times until you see a message indicating that you are now a developer.
2. Access Developer Options: Once you have enabled the Developer Options, go back to the main settings menu and look for the newly unlocked “Developer options” entry. Tap on it to access the developer settings.
3. Enable USB Debugging: Within the Developer Options, locate the “USB debugging” option and enable it. This will allow your computer to communicate with the Android device over a USB connection.
4. Connect Android Device to Computer: Connect your Android device to your computer using a USB cable. Make sure to authorize the computer‘s RSA key fingerprint on your device if prompted.
5. Open Command Prompt or Terminal: On Windows, open the Command Prompt by pressing the Windows key + R, typing “cmd,” and hitting Enter. On Mac/Linux, open the Terminal by searching for it in the applications or using the keyboard shortcut Command + Space and typing “Terminal.”
6. Navigate to Android SDK Tools: In the Command Prompt or Terminal, navigate to the directory where you have installed the Android SDK tools. This is typically located in the “platform-tools” folder within the Android SDK installation directory.
7. Execute ADB Commands: Once you are in the Android SDK tools directory, execute the following command to list all the connected devices:

adb devices

This will display the device ID of your connected Android device.

1. Find App Package and Activity: To find the app package and activity, execute the following command:

adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp'

This command will provide you with the current app package and activity details.

Commands for Windows and Mac/Linux

Here are the commands for finding the app package and activity in Android using Appium on both Windows and Mac/Linux platforms:

Windows:

1. Enable Developer Options on your Android device.
2. Connect your Android device to your computer via USB.
3. Open the Command Prompt by pressing the Windows key + R, typing “cmd,” and hitting Enter.
4. Navigate to the Android SDK tools directory using the cd command.
5. Execute the command adb devices to list the connected devices.
6. Execute the command adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp' to find the app package and activity.

Mac/Linux:

1. Enable Developer Options on your Android device.
2. Connect your Android device to your computer via USB.
3. Open the Terminal by searching for it in the applications or using the keyboard shortcut Command + Space and typing “Terminal.”
4. Navigate to the Android SDK tools directory using the cd command.
5. Execute the command ./adb devices to list the connected devices.
6. Execute the command ./adb shell dumpsys window windows | grep -E 'mCurrentFocus|mFocusedApp' to find the app package and activity.

By following these steps and executing the appropriate commands, you can easily find the app package and activity of an Android application. This information is essential for writing effective scripts in Appium testing, as it allows you to interact with specific screens and functionalities within the app.

How to Create a Maven Project for Appium Testing

Appium is an open-source automation tool used for testing mobile applications. It allows you to write scripts in various programming languages to automate the testing process. In this section, we will discuss how to create a Maven project for Appium testing, which will help you manage dependencies and build your project more efficiently.

Prerequisites for Creating a Maven Project

Before we dive into creating a Maven project for Appium testing, let’s ensure we have the necessary prerequisites in place. Here are a few things you’ll need:

1. Java Development Kit (JDK): Make sure you have the latest version of JDK installed on your system. Maven requires JDK to compile and run your code.
2. Maven: Install Maven on your machine. You can download the latest version of Maven from the official Apache Maven website.
3. Integrated Development Environment (IDE): Choose an IDE of your preference. Popular choices include Eclipse, IntelliJ IDEA, and Visual Studio Code. Install the necessary plugins for Maven integration.
4. Appium Server: Download and install the Appium server on your machine. Appium server acts as a bridge between your test scripts and the mobile device or emulator.

Steps to Create a Maven Project

Now that we have the prerequisites sorted, let’s move on to creating a Maven project for Appium testing. Follow these steps:

1. Open your IDE: Launch your preferred IDE and create a new Maven project. Choose the appropriate Maven archetype for your project. For Appium testing, the “maven-archetype-quickstart” archetype is commonly used.
2. Configure project details: Provide the necessary details such as Group Id and Artifact Id for your project. These details will be used to identify your project within the Maven ecosystem.
3. Project structure: Once the project is created, you will see a predefined project structure. The main source code files will be located under the “src/main/java” directory.
4. Create a test class: Inside the “src/main/java” directory, create a new package for your test scripts. Create a new Java class within this package to write your Appium test scripts.
5. Configure dependencies: We will now add the necessary dependencies to the project’s pom.xml file. This file is located in the root directory of your project. Open the pom.xml file and add the required dependencies for Appium testing.

Adding Dependencies to the pom.xml File

To successfully run Appium tests, we need to add the required dependencies to the pom.xml file. These dependencies will be downloaded by Maven and included in your project’s classpath. Here are a few commonly used dependencies for Appium testing:

To add these dependencies, open the pom.xml file and locate the <dependencies> section. Add the necessary dependencies within the <dependencies> tags. Here’s an example:

xml
<dependencies>
<dependency>
<groupId>io.appium</groupId>
<artifactId>java-client</artifactId>
<version>7.5.1</version>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.4.0</version>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>3.141.59</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
</dependencies>

Once you have added the dependencies, save the pom.xml file. Maven will automatically download the required dependencies and make them available in your project.

Congratulations! You have successfully created a Maven project for Appium testing and added the necessary dependencies. Now you can start writing your Appium test scripts and execute them using Maven.

In the next section, we will explore how to write effective test scripts in Appium and discuss best practices for script development. Stay tuned!

Desired Capabilities in Appium Testing

In Appium testing, desired capabilities play a crucial role in configuring and customizing the test automation process. Desired capabilities are a set of key-value pairs that define the characteristics of the test environment, such as the platform, device, and application settings. By specifying these capabilities, testers can ensure that their Appium scripts run on the desired target device or emulator.

When writing scripts in Appium, it is essential to understand how to set the desired capabilities correctly. Let’s explore the desired capabilities for Android and iPhone devices.

Desired Capabilities for Android

When testing Android applications with Appium, there are several desired capabilities that you can set to configure the test environment. Here are some commonly used desired capabilities for Android:

1. platformName: Specifies the platform on which the test will run, such as “Android” or “iOS.”
2. deviceName: Specifies the name of the Android device or emulator on which the test will execute.
3. app: Specifies the path to the APK file or the package name of the application under test.
4. automationName: Specifies the automation engine to be used, such as “UiAutomator2” or “Espresso.”
5. appPackage and appActivity: Specifies the package name and activity name of the application under test, respectively.
6. udid: Specifies the unique device identifier (UDID) of the Android device.

By setting these desired capabilities, you can configure the test environment to match your specific requirements for Android testing.

Desired Capabilities for iPhone

Similar to Android, when testing iPhone applications with Appium, you can set desired capabilities to customize the test environment. Here are some commonly used desired capabilities for iPhone:

1. platformName: Specifies the platform on which the test will run, such as “Android” or “iOS.”
2. deviceName: Specifies the name of the iPhone device or simulator on which the test will execute.
3. app: Specifies the path to the .app file or the bundle identifier of the application under test.
4. automationName: Specifies the automation engine to be used, such as “XCUITest” or “UIAutomation.”
5. bundleId: Specifies the bundle identifier of the application under test.
6. udid: Specifies the unique device identifier (UDID) of the iPhone device.

By setting these desired capabilities, you can configure the test environment to match your specific requirements for iPhone testing.

How to Write an Appium Testing Script for Android

Appium is an open-source automation tool that enables you to write and execute tests for mobile applications. It supports both Android and iOS platforms, making it a popular choice among developers and testers. In this section, we will discuss the steps involved in writing an Appium testing script for Android and provide a sample code for reference.

Steps to Write an Appium Testing Script

Writing an Appium testing script requires a systematic approach to ensure accurate and efficient test execution. Here are the steps you can follow to write an Appium testing script for Android:

1. Set up the development environment: Before you begin writing the script, you need to set up the development environment. This includes installing the necessary software, such as Java Development Kit (JDK), Android SDK, and Appium server. Make sure to configure the environment variables properly.
2. Identify the test scenarios: Determine the test scenarios you want to cover in your script. This involves understanding the functionality of the application and identifying the key features that need to be tested. It is important to have a clear understanding of the expected behavior of the application under different conditions.
3. Inspect the application: Use the Appium Inspector tool to inspect the elements of the application. This tool allows you to identify the unique identifiers (such as resource-id, class name, or xpath) for the elements you want to interact with during the test. Inspecting the application helps you in locating the elements accurately in your script.
4. Write the test script: Once you have identified the test scenarios and inspected the application, you can start writing the test script. The script should be written in a programming language that is supported by Appium, such as Java, Python, or JavaScript. You can use any Integrated Development Environment (IDE) of your choice to write the script.
5. Configure the desired capabilities: Before executing the test script, you need to configure the desired capabilities. Desired capabilities are a set of key-value pairs that define the characteristics of the test environment, such as the device name, platform name, and application package name. These capabilities help Appium in establishing a connection with the device and launching the application.
6. Implement test actions: In the test script, you need to implement the test actions that simulate user interactions with the application. These actions can include tapping on elements, entering text, swiping, scrolling, or any other action that you want to perform during the test. You can use the element locators identified during the inspection phase to interact with the elements.
7. Add assertions: Assertions are used to verify the expected behavior of the application. You can add assertions in your test script to check if the application is behaving as expected. For example, you can assert that a certain element is present on the screen, or the text entered in a text field is displayed correctly.
8. Execute the test script: Once you have written the test script, you can execute it using the Appium server. Make sure to connect the device or emulator to the computer and start the Appium server before executing the script. The server will establish a connection with the device and execute the test script, providing you with the test results.

Sample Code for Reference

Here is a sample code snippet in Java that demonstrates how to write an Appium testing script for Android:

“`java
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.AndroidElement;
import org.openqa.selenium.remote.DesiredCapabilities;
import java.net.URL;

public class AppiumTestScript {
public static void main(String[] args) throws Exception {
// Set the desired capabilities
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(“deviceName”, “Android Device”);
caps.setCapability(“platformName”, “Android”);
caps.setCapability(“appPackage”, “com.example.app”);
caps.setCapability(“appActivity”, “com.example.app.MainActivity”);

    // Create a new instance of the AndroidDriver
    AndroidDriver<AndroidElement> driver = new AndroidDriver<>(new URL("http://localhost:4723/wd/hub"), caps);

    // Perform test actions
    // ...

    // Add assertions
    // ...

    // Close the driver
    driver.quit();
}

}
“`

This code sets the desired capabilities, creates an instance of the AndroidDriver, performs test actions, adds assertions, and finally closes the driver. You can customize the code according to your test scenarios and application.

Writing an Appium testing script for Android requires a combination of technical skills and understanding of the application under test. By following the steps mentioned above and referring to the sample code, you can create effective and reliable test scripts for your Android applications using Appium.

How to Write an Appium Testing Script for iPhone

Appium is an open-source automation tool that allows you to automate mobile app testing across different platforms, including iOS. In this section, we will explore the steps to write an Appium testing script for iPhone and provide a sample code for reference.

Steps to Write an Appium Testing Script

Writing an Appium testing script for iPhone involves several steps. Let’s walk through them one by one:

1. Set up the environment: Before you start writing the script, ensure that you have the necessary tools installed. This includes Appium, Xcode, and the iOS Simulator. You can install these tools by following the official documentation provided by Appium and Apple.
2. Create a new project: Once your environment is set up, create a new project in your preferred programming language. Appium supports multiple programming languages, such as Java, Python, and JavaScript. Choose the language you are comfortable with and create a new project.
3. Import the necessary libraries: In your project, import the necessary libraries or dependencies required for Appium. These libraries provide the functions and methods needed to interact with the Appium server and control the iOS Simulator.
4. Set desired capabilities: Before launching the Appium server, set the desired capabilities for your iPhone device. These capabilities include the device name, platform version, and app package name. You can find the desired capabilities specific to your device in the Appium documentation.
5. Start the Appium server: Launch the Appium server using the desired capabilities you set in the previous step. The Appium server acts as a bridge between your script and the iOS Simulator, allowing you to interact with the app.
6. Write test cases: Now it’s time to write the actual test cases in your script. Test cases are a set of instructions that simulate user interactions with the app. For example, you can write test cases to tap on a button, enter text in a text field, or verify the presence of an element on the screen.
7. Execute the script: Once you have written the test cases, execute the script. The script will communicate with the Appium server, which in turn interacts with the iOS Simulator and performs the actions specified in the test cases.

Sample Code for Reference

Here’s a sample code snippet in Java that demonstrates how to write an Appium testing script for iPhone:

“`java
import io.appium.java_client.MobileElement;
import io.appium.java_client.ios.IOSDriver;
import org.openqa.selenium.remote.DesiredCapabilities;

public class AppiumTest {
public static void main(String[] args) {
// Set desired capabilities
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(“platformName”, “iOS”);
caps.setCapability(“platformVersion”, “14.5”);
caps.setCapability(“deviceName”, “iPhone 12”);
caps.setCapability(“app”, “path/to/your/app”);

    // Create driver instance
    IOSDriver<MobileElement> driver = new IOSDriver<>("http://localhost:4723/wd/hub", caps);

    // Write test cases
    // ...

    // Execute the script
    // ...

    // Quit the driver
    driver.quit();
}

}
“`

In this code snippet, we import the necessary libraries, set the desired capabilities for the iPhone device, create an instance of the driver, write test cases, execute the script, and finally quit the driver.

Feel free to modify and customize this sample code according to your specific testing requirements.

By following these steps and referring to the sample code, you can start writing your own Appium testing script for iPhone. Remember to explore the Appium documentation and experiment with different test cases to ensure comprehensive test coverage for your mobile app.

TestNG Assert in Appium Testing

Explanation of TestNG Assert

When it comes to appium testing, one of the essential aspects is the ability to verify whether the expected behavior of the application is met. This is where TestNG Assert comes into play. TestNG is a testing framework that provides a set of assertion methods to validate the expected outcomes of your test cases.

TestNG Assert allows you to check if a particular condition is true and throws an exception if it is not. It helps in ensuring that the app is functioning as expected and helps identify any discrepancies or bugs in the application.

Usage of TestNG Assert in the code

To understand the usage of TestNG Assert in appium testing, let’s consider an example scenario. Suppose we have an app that has a login functionality, and we want to verify if the login is successful.

Here’s how you can use TestNG Assert in your appium test script:

1. Import the necessary TestNG and appium libraries:

java
import org.testng.Assert;
import io.appium.java_client.MobileElement;
import io.appium.java_client.android.AndroidDriver;

1. Set up the desired capabilities and initialize the appium driver:

“`java
DesiredCapabilities caps = new DesiredCapabilities();
caps.setCapability(“deviceName”, “Your_Device_Name”);
caps.setCapability(“platformName”, “Android”);
caps.setCapability(“appPackage”, “com.example.app”);
caps.setCapability(“appActivity”, “com.example.app.MainActivity”);

AndroidDriver driver = new AndroidDriver(new URL(“http://127.0.0.1:4723/wd/hub”), caps);
“`

1. Write the test case to verify the login functionality:

“`java
@Test
public void testLogin() {
// Perform actions to navigate to the login screen

// Enter valid credentials
driver.findElement(By.id("username")).sendKeys("testuser");
driver.findElement(By.id("password")).sendKeys("password");

// Click on the login button
driver.findElement(By.id("loginButton")).click();

// Verify if the login is successful
Assert.assertTrue(driver.findElement(By.id("welcomeMessage")).isDisplayed(), "Login failed!");

}
“`

In the above code snippet, we first navigate to the login screen and enter valid credentials. Then, we click on the login button. Finally, we use TestNG Assert to check if the welcome message is displayed after a successful login. If the welcome message is not displayed, the assertion will fail, and the specified error message “Login failed!” will be shown.

By using TestNG Assert, you can easily validate various aspects of your app‘s functionality, such as checking if elements are present, verifying text values, or validating expected behaviors.

Summary

References

Here are some valuable resources that can help you in writing scripts for Appium testing:

1. Maven documentation: Maven is a popular build automation tool used in Java projects. It simplifies the process of managing dependencies and building projects. The Maven documentation provides detailed information on how to set up Maven for your Appium testing project, including the necessary configurations and dependencies. It also offers guidance on how to structure your project and manage its lifecycle. You can find the official Maven documentation here.
2. TestNG documentation: TestNG is a testing framework that can be integrated with Appium to create robust and scalable test scripts. It provides advanced features such as parallel test execution, data-driven testing, and test configuration through XML files. The TestNG documentation offers comprehensive guidance on how to write test scripts using TestNG annotations, assertions, and other features. It also covers topics like test configuration, test suites, and reporting. You can access the official TestNG documentation here.

By referring to these resources, you can enhance your understanding of Appium testing and improve your script writing skills. These documentation sources provide step-by-step instructions, code examples, and best practices to help you write efficient and maintainable test scripts.

Additionally, you can explore online forums, blogs, and tutorials dedicated to Appium testing. These platforms often provide practical examples, tips, and tricks shared by experienced professionals in the field. Engaging with the Appium testing community can further expand your knowledge and help you stay up-to-date with the latest developments in the field.

Remember, writing effective scripts requires a combination of technical knowledge, understanding of the application under test, and a systematic approach. By leveraging the resources mentioned above and continuously practicing and refining your skills, you can become proficient in writing scripts for Appium testing.

Frequently Asked Questions

How to write appium tests?

To write appium tests, you need to follow these steps:
1. Set up the necessary environment for appium.
2. Write the test script using the appium scripting language.
3. Use the appropriate appium commands to interact with the mobile application.
4. Run the test script and analyze the results.

How to write a test script for software testing?

To write a test script for software testing, you can follow these guidelines:
1. Identify the test scenario and the expected outcome.
2. Define the necessary test data and test environment.
3. Write the test steps in a clear and concise manner.
4. Include assertions to validate the expected results.
5. Consider error handling and exception scenarios.
6. Execute the test script and analyze the test results.

How to run appium scripts in Jenkins?

To run appium scripts in Jenkins, you can follow these steps:
1. Install the necessary plugins for appium integration in Jenkins.
2. Set up the Jenkins job to execute the appium script.
3. Configure the job to use the appropriate appium server and device configurations.
4. Schedule the job to run at the desired frequency or trigger it manually.
5. Monitor the Jenkins console output for the test execution results.

How to write automated test scripts?

To write automated test scripts, you can follow these steps:
1. Identify the test scenarios that can be automated.
2. Choose an appropriate automation framework or tool.
3. Set up the necessary environment for test automation.
4. Write the test scripts using the chosen automation tool or programming language.
5. Include assertions and validations to verify the expected results.
6. Execute the automated test scripts and analyze the test results.

How to write appium code in Eclipse?

To write appium code in Eclipse, you can follow these steps:
1. Install the necessary plugins for appium integration in Eclipse.
2. Set up the project and configure the build path.
3. Create a new class or package to hold the appium code.
4. Write the appium script using the appium scripting language.
5. Use the appropriate appium commands to interact with the mobile application.
6. Run the appium script from Eclipse and analyze the results.

What is a test script in software testing with example?

A test script in software testing is a set of instructions or commands that define the steps to be executed to validate the functionality of a software application. It typically includes the input data, the expected output, and any assertions or validations to be performed.

For example, a test script for a login functionality may include steps like entering valid credentials, clicking the login button, and verifying that the user is successfully logged in.

How to write appium test script example?

To write an appium test script example, you can follow these steps:
1. Set up the necessary environment for appium.
2. Write the test script using the appium scripting language.
3. Use appium commands to interact with the mobile application.
4. Include assertions or validations to verify the expected results.
5. Run the test script and analyze the results.

What are the best practices for appium script development?

Some best practices for appium script development include:
1. Using descriptive and meaningful variable and method names.
2. Organizing the code into reusable functions or modules.
3. Implementing proper error handling and exception handling.
4. Using appropriate waits and synchronization techniques.
5. Implementing logging and reporting mechanisms.
6. Regularly reviewing and refactoring the code for better maintainability.

How to debug appium scripts?

To debug appium scripts, you can follow these steps:
1. Enable the debugging mode in your appium setup.
2. Use breakpoints or logging statements in your script to identify the issue.
3. Analyze the logs and error messages to pinpoint the problem.
4. Use the appium inspector or other debugging tools to inspect the application state during script execution.
5. Make necessary changes to the script and re-run it to verify the fix.

What are some tips for writing appium scripts?

Here are some tips for writing appium scripts:
1. Plan and design your test scenarios before writing the script.
2. Use descriptive and meaningful names for elements and variables.
3. Implement proper error handling and exception handling.
4. Use appropriate waits and synchronization techniques.
5. Include assertions or validations to verify the expected results.
6. Regularly review and refactor your script for better maintainability.

Himadri Das

Hi, I am Himadri Das, I am a blogger, and an open source contributor. I have about 11 years of experience in the Information Technology domain. Currently I am working in a Startup Company as Quality Assurance Manager. I have hands-on experience on Appium, Selenium, QTP, Locust, Automation framework, Performance Testing, Functional Testing, Java, python, Shell scripting, MySql, Redis, Kafka etc. Apart from my work and writing blogs, I love to play guitar, love to travel and love to watch cricket and football. If you want to know more about me, please visit my linkedin profile .