DEV Community: Sidharth Shukla

Appium Testing Tutorial For Mobile Applications

Sidharth Shukla — Tue, 03 Jan 2023 16:58:16 +0000

The count of mobile users is on a steep rise. According to the research, by 2025, it is expected to reach 7.49 billion users worldwide. 70% of all US digital media time comes from mobile apps, and to your surprise, the average smartphone owner uses ten apps per day and 30 apps each month.

In the present world, there are apps for every mobile device and purpose, and feedback is an integral part of their improvement process. With the emerging technology and demand for faster releases, it is quite important to make sure that the mobile apps need to be tested thoroughly before it is released to the customers.

There are many tools available to perform mobile app testing in the market. Still, there are more challenges in mobile app testing than web application testing, as there is a huge fragmentation when it comes to mobile devices & mobile operating systems. You can learn more about Android and iOS fragmentation from our earlier blog on how to deal with iOS version fragmentation.

Amongst all the mobile automation tools (or frameworks), Appium is one of the most popular open-source test automation frameworks for mobile app testing. It is cross-platform and compatible with a number of popular programming languages (e.g., Java, Python, JavaScript, etc.) for app test automation. The best part is that you don’t have to recompile your app or modify it due to the usage of standard automation APIs on the supported platforms.

While Selenium is still the king of the web, Appium rules the mobile domain, with 35% of the organization preferring it over other free/open-source functional automation tools.

In this Appium testing tutorial, we will deep dive into the essentials of the Appium framework for performing mobile automation tests.

Introduction to Appium testing

Appium is an open-source framework for automating native, mobile web, and hybrid applications on Android mobile, iOS mobile, and Windows desktop platforms. For starters, Appium was developed by Dan Cuellar and Jason Huggins and today has about 15.2K stars and 5.7K Fork on GitHub. It has the highest market share compared to all the other mobile automation frameworks.

Here are the major categories of mobile applications that can be tested using the Appium framework:

Native apps — These are written using the iOS, Android, or Windows SDKs. Instagram, Spotify, and Facebook are some of the most popular native mobile apps.
Mobile web apps — These are applications accessed using a mobile browser. Appium supports Safari on iOS and Chrome or the built-in ‘Browser’ app on Android. Uber and Pinterest are some of the most popular mobile web applications.
Hybrid apps — These applications have a wrapper around a “webview” — a native control that enables interaction with the web content. Projects like Apache Cordova make it easy to build new apps using web technologies bundled into a native wrapper, creating a hybrid app. LinkedIn and Facebook are the most popular hybrid mobile applications.
Progressive Web Apps (PWAs) — Progressive Web Apps are almost the same as regular web pages. In fact, they also function when the device is in offline mode (i.e., when the device is not connected to the Internet). The best thing about these “PWAs” is that they can be accessed via the app icon on the device. By clicking on it, the icon launches the app website.

Intrigued to know more about Web, Hybrid, and Native apps? You can deep-dive into it by going through the Web vs Hybrid vs Native Apps comparison.

Appium is “cross-platform”; hence, tests written for one platform (i.e., Android, iOS, etc.) work seamlessly across other platforms supported by the Appium framework. This increases the code reusability factor and minimizes the code maintainability factor of the test code.

Watch this video to learn about Appium, one of the most popular open-source test automation frameworks for mobile app testing.

Platforms supported by Appium

Before we start discussing Appium Mobile Testing in greater detail, we should know about the platforms supported by Appium. In my personal experience, if we aren’t aware of the support provided by Appium, you may waste your time trying out some implementation that might not be supported by Appium.

Appium supports multiple platforms and testing modalities mentioned below:

Native Apps
Hybrid Apps
Web Apps
Testing on Real devices
Testing on Simulators and Emulators

Appium supports iOS, Android, macOS, and Windows. Here is the list of drivers required for each platform:

**iOS **Support for XCUITest Driver and SafariDriver for Apple’s Safaridriver.
Android **supports UiAutomator2 Driver, Espresso Driver, and Geckodriver for Firefox and GeckoView. However, UIAutomation Driver **support has been deprecated for both iOS and Android.
**macOS **support for Mac2 Driver is for macOS 10.15 (or later). Windows Desktop supports WinAppDriver Geckodriver for Firefox and GeckoView.

Apart from these, some vendors/community-based drivers can be found on the Appium official website.

In case you are a beginner to Appium you can learn to perform mobile app testing easily through this tutorial.

How to install Appium?

Appium can be installed in two ways:

Via NPM (Node Package Manager).
By downloading Appium Desktop — a graphical, desktop-based way to launch the Appium server.

Installation of Appium via NPM

If you want to run Appium via an npm install, you will need Node.js and NPM (use nvm, n, or brew install node to install Node.js).

Ensure that Node or Appium are not installed with sudo (or root); otherwise, you’ll run into problems. We recommend the latest stable version, though Appium supports Node.js 12+.

Run the following command on the terminal to install Appium via npm:

  npm install -g appium

Once installation is done, we can type “npm — -version,” which will return the installed version as shown below:

Installation of Appium via Desktop App

Simply download the latest version of Appium Desktop from the releases page of Appium official website.

How to start the Appium Server?

Appium server is basically written in Node.js and follows the HTTP JSON Wire Protocol. It acts as a virtual server that sends the commands to the framework to handle testing actions and scripts autonomously.

The Appium server processes the request and then responds with the test results. Now we can kick up an Appium server, either by running it from the command line or by using Appium Desktop (assuming the npm install was successful).

We can use the below command to start the appium server:

  ⇒ appium

2- You will get to see Welcome to Appium like the below screenshot:

3- If you have installed Appium Desktop, then we can start by clicking on the ‘Start Server’ button inside of Appium Desktop as shown below.

4- Appium will now show you a little welcome message showing the version of Appium you’re running and what port it’s listening on (the default is 4723: You can use “netstat” to check whether a port is available or not).

5- You can use port number 4726 instead of 4723. However, the server needs to be configured to run on the said port. This port information is vital since you will have to direct your test client to make sure to connect to Appium on this port. If you want to change the port, you can do so by using the -p flag when starting Appium (be sure to check out the full list of server parameters).

Bonus Tip

There is an easy way to start Appium server programmatically:

   AppiumDriverLocalService service = AppiumDriverLocalService.buildDefaultService();
    service.start(); // start the Appium Server
    service.stop(); // stop the Appium Server

Android Emulators for Appium testing

In my ten years of experience, I have observed that when we want to test mobile applications, we always prefer to do the dry run on emulators. In fact, most organizations prefer emulators for running a regression suite for Appium testing. So it is quite vital to know about emulators and how to create one for Appium testing.

Android emulator is a tool that creates virtual Android devices (with both software and hardware) that can be used for running Android device tests that are implemented using the Appium framework. You can go through the blog on emulator vs simulator differences to learn about emulators and simulators.

Android emulators are very important for performing Android app testing. Below are the steps to create an Android Mobile Emulator, which we can use for Mobile testing on any Android version.

Download and install Android Studio in case it is not present on your machine.
Open Android Studio and click on “Configure” “AVD Manager” from the list as shown in the below screenshot.

3- Now click on the “Create Virtual Device” button, and you will be redirected to the “Select Hardware” page, where we need to select the mobile type, for example, “Pixel XL,” as shown below and then click on “Next”.

4- After the “Select Hardware” page you will be able to see the “System Image” page. Here we need to select which Android version we want in our mobile device for testing, for example, Pie, Oreo, R, etc. In the below image, you can see that I have selected Android 11, then click “Next.”

Here, we can change the Memory and Storage by clicking on “Show Advanced Settings.”

5- Now you will arrive at the “Verify Configuration” page. Here, you can check the selection we have made in steps 3 and 4. Provide the name for your device as I have given the name “AndroidMobile” in the below screenshot:

6- Now the device is created, and in the dashboard, we can see it. Search with the device name that we have provided in Step 5, as shown below. Now click on the ‘Play’ button, and the device is ready for testing.

In the above screenshot, we have an edit option, which can be used to edit some fields for the emulator, and the dropdown button can be used for cold boot.

But sometimes, it’s really difficult to go through all the six steps mentioned above to create an emulator. So, instead of that, you can also use online Android emulators provided by LambdaTest.

Cloud-based cross browser testing platforms like LambdaTest provides an online device farm of over 3000+ Android emulators to test on Android devices.

We need to run just three steps to start an emulator on LambdaTest:

Login to LambdaTest and go to the LambdaTest Dashboard.
Navigate to Real Time Testing > App Testing as shown below:

3- Now select your BRAND **and **DEVICE/OS and then click on the START button. Here, the sample apk is mentioned, but you can use your apk for Appium testing.

Isn’t it easy :), Don’t forget to stop the emulator after use by clicking on the last button on the left panel.

Check this out: Regression testing- Complete Guide With Best Practices

Installing App on Emulators

Once the emulator is ready for use and the Android path is set up correctly, the next step would be to install an app on the emulator on which we would be performing the app testing.

The first step is to run the emulator on which you need to install the app.

   emulator -avd

2- The emulator will be launched, and the command will run in the terminal.

3- There are two ways to install the app:

Install via ADB command:

Download the apk and put it in folder
Run the following command

adb install path/to/your/app.apk
When multiple emulators are open, run the following command
adb -s serial-number-of-device install path/to/your/app.apk

Drag and Drop

We can also drag the apk file and drop on to the emulator, which will install the application.

Now perform testing by dragging your .apk to the newly created virtual device. There are many websites that provide the sample apk, which can be used for testing. If you do not have any .apk or .ipa files, you can run your sample tests on LambdaTest using our sample 🔗 Android app or sample 🔗 iOS app.

How to identify elements for Appium testing?

Before we can start writing test scripts, we need to understand identifying elements using attributes such as ID, Name, Class, etc., to perform actions. You can go through this Selenium Locators tutorial to learn more about the locators.

To identify (or locate) elements, we can use UIAutomatorViewer or Appium inspector to capture a snapshot of the current device screen, which shows the hierarchy of the UI components properly arranged on the screen.

UI Automator Viewer is a GUI tool that comes with Android SDK and is primarily used to inspect UI components of the Android Application. It also lets you view the properties associated with it. We can find it in the Android SDK “tools” folder with the file name ‘uiautomatorviewer.bat’ on Windows OS.

How to access elements using UIAutomatorViewer?

When designing automation scripts, Appium uses “UIAutomatorViewer” to identify different properties of the object and use the properties to identify the required object.

There are several ways by which the UIAutomatorViewer can be launched:

For Windows: Go to the path where UIAutomatorViewer exists (Android SDK folder) and run the batch file (for Windows) — uiautomatorviewer.bat.
For Mac: Go to the location via terminal and run the uiautomatorviewer sh file. Execution permission must be given to the file, or errors will be thrown.
It can be added as an alias to run directly via the terminal. In the Mac machine, add it to the bash_profile file.

Example: alias inspector='$ANDROID_HOME/tools/bin/uiautomatorviewer'

For Mac:

Follow the below mentioned steps for using UIAutomatorViewer:

Connect the device to the PC via USB cable.
Enable USB Debugging mode for the device connected.
Run the ADB devices command in the command prompt/terminal to check if the device is detected and online/available.
Open an application and click the device screenshot icon from the right up corner.

5- After clicking on ‘Device Screenshot‘, an image of the current screen will be loaded in the UIAutomatorViewer, and we can use the mouse to click on any element and see the details of that element. You can also use the hierarchical tree in the top right to browse a particular element.

Note: The UIAutomatorViewer works only with Android native app elements.

Want to make your life of testing easy and fuss-free while debugging? Try LT Debug Chrome extension!

Check this out: Mobile Emulator Online- Test your mobile websites and smartphone apps using our scalable on cloud mobile emulator.

How to work with Appium Inspector?

A default inspector available in standalone Appium (not in the npm version) is called Appium Inspector, which can be used to inspect Android and iOS elements. It simply mirrors the screen of the device, and we can interact with it and get the details of the elements. Let’s see how we can launch and work with it.

Launch Appium from your application/programs menu by clicking on Start Server. You can refer to the screenshot in the “How to start the Appium Server” section of this blog.

2- Click the Search icon from the right up corner.

Add correct desired capabilities as per your device/emulator and application. Then click on the Start Session button.

4- It will open the App screen, App Source (the hierarchy of elements), and Selected Element Pane (The attributes and associated values of the element). You can use this to create locators which will uniquely identify the element.

5- You can provide a .apk or .app file in desired capabilities inside Appium Inspector, which will install and launch the app. Refer to the screenshots below, which we have used to test .apk and passed in the value against “app.”

6- Best thing about the Appium Inspector is that you can verify your written locator on screen. Check the below screenshots.

If your locator is correct, then it will highlight the associated element.

Sometimes the screen on the left and your emulator won’t be in sync, so we need to click on the refresh button to bring the screen and emulator in sync:

Locators used for Mobile Automation

Shown below are some of the major locators used for mobile app automation:

STRATEGY	DESCRIPTION
Accessibility ID	Reads a unique identifier for a UI element. For XCUITest, it is the element’s accessibility-id attribute. For Android, it is the element’s content-desc attribute.
Class name	For iOS, it is the full name of the XCUI element and begins with XCUIElementType. For Android it is the full name of the UIAutomator2 class (e.g., android.widget.TextView)
ID	Native element identifier. resource-id for android; name for iOS.
Name	Name of element.
XPath	Searches the app XML source using xpath (not recommended, has performance issues)
Image	Locates an element by matching it with a base 64 encoded image file
Android UiAutomator (UiAutomator2 only)	Uses the UIAutomator API, in particular, the UiSelector class to locate elements. In Appium, you send the Java code, as a string, to the server, which executes it in the application’s environment, returning the element or elements.
Android View Tag (Espresso only)	Locates an element by its view tag.
Android Data Matcher (Espresso only)	Locates an element using Espresso DataMatcher.
iOS UIAutomation	When automating an iOS application, Apple’s Instruments framework can be used to find elements.

Check this out: WebDriver Tutorial: A Comprehensive Guide on Selenium WebDriver Automation

How to run Appium tests on iOS and Android?

In this section of this Appium testing tutorial, I will walk you through the steps for running Appium tests with iOS and Android. First, make sure the Appium server is up and running. You can refer to the section “How to start the Appium Server” in this blog to kick start your first step for Appium testing.

Then, we have to check that the Android emulator we have created in the section “Android Emulators for Appium testing” is up and running. For that, we need to run adb devices. For example, we should see one device connected, as shown in the below screenshot. This is the device Appium will use for testing purposes. (Remember that if the Android SDK tools are on your path, simply run: emulator -avd )

Now we need to wait for the Android emulator to finish launching. Sometimes, for various reasons, adb gets stuck. If it’s not showing any connected devices or otherwise failing, we can restart it by running: adb kill-server && adb devices.

Once we are done with starting the Appium server and checking the emulator, then we should be aware of the desired capabilities as per the OS(Android/iOS) we are using for Appium testing.

Android: Set the following desired capabilities in your WebDriver script:

    DesiredCapabilities capabilities = new DesiredCapabilities();
    capabilities.setCapability(MobileCapabilityType.PLATFORM_NAME, "iOS");
    capabilities.setCapability(MobileCapabilityType.PLATFORM_VERSION, "7.1");
    capabilities.setCapability(MobileCapabilityType.DEVICE_NAME, "iPhone Simulator");
    capabilities.setCapability(MobileCapabilityType.APP, myApp);

Using your WebDriver library of choice, set the remote session to use these capabilities and connect to the server running at port 4723 of localhost (or whatever host and port you specified when you started Appium). You are all set now!

There are many ways to start an Appium application (it will work exactly the same way as when the application is started via ADB command):

apk or zip only, default activity will be launched (‘app’ capability)
apk + activity (‘app’ + ‘appActivity’ capabilities)
apk + activity + intent (‘app’ + ‘appActivity’ + ‘appIntent’ capabilities)

If you are not sure what activity is configured in your apk, you can proceed in one of the following ways:

Mac/Linux: ‘adb shell dumpsys window windows | grep mFocusedApp’
In the Ruby console: ‘adb shell dumpsys window windows`.each_line.grep(/mFocusedApp/).first.strip’
In Windows terminal, run ‘adb shell dumpsys window windows’ and manually look for the mFocusedApp line.

iOS: Set the following desired capabilities in your WebDriver script::

DesiredCapabilities capabilities = new DesiredCapabilities(); capabilities.setCapability(MobileCapabilityType.PLATFORM_NAME, "Android"); capabilities.setCapability(MobileCapabilityType.PLATFORM_VERSION, "4.4"); capabilities.setCapability(MobileCapabilityType.DEVICE_NAME, "Android Emulator"); capabilities.setCapability(MobileCapabilityType.APP, myApp);

In the set of capabilities for Android and iOS, myApp must be any one of the below:

A local absolute path to your .apk or a .zip
An URL of a zip file containing your .apk
path to one of the sample app relative to the appium install root

Using the WebDriver library of choice, we can set the remote session to use these capabilities and connect to the server running at port 4723 of localhost . You should be all set now!

Check this out: Test On iPhone tester Simulator On Cloud

Appium testing with Demo Code

Here, we are using simple code, which can be used by anyone for their first test on Appium. We are using an emulator that we created in this post to run our apk, which can be downloaded from the ”Installing App on Emulators” section of this post.

We will try to verify two important scenarios in the test below, the first one is “open the geolocation page” and the second one is “speed test page”. Apart from the code, I will share the screenshot on the emulator while running the test script for both the scenarios mentioned above.

Sometimes it’s difficult to start from scratch, so to make life easier, you can clone the LambdaTest’s 🔗LT-appium-java repository and then replace the vanilla_android.java class with the code mentioned below.

Now we are halfway done. We just need to hit the below two commands to run our sample test for Appium testing on Android APK emulator online. The first command is to install dependencies and second one to run our suite.

To install the required dependencies:

mvn clean install

To run your test just type below command in your command prompt:

mvn compile exec:java -Dexec.mainClass=vanilla_android -Dexec.classpathScope=”test”

Sample Code:

`
import io.appium.java_client.AppiumDriver;
import io.appium.java_client.MobileBy;
import io.appium.java_client.MobileElement;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.MalformedURLException;
import java.net.URL;

public class vanilla_android {
   private static AppiumDriver driver;

   public static void main(String args[]) throws MalformedURLException, InterruptedException {

       try {
           DesiredCapabilities capabilities = new DesiredCapabilities();
           capabilities.setCapability("deviceName", "AndroidMobile");
           capabilities.setCapability("platformVersion", "11");
               capabilities.setCapability("platformName", "Android");
           capabilities.setCapability("isRealMobile", false);
           capabilities.setCapability("app", "/Users/{user}/Downloads/proverbial_android.apk"); //Enter your app url
           capabilities.setCapability("name", "Sample Test Java");
           capabilities.setCapability("console", true);
           capabilities.setCapability("network", false);
           capabilities.setCapability("visual", true);
           capabilities.setCapability("devicelog", true);


           driver = new AppiumDriver(new URL("http://localhost:4723/wd/hub"), capabilities);

           //Open the geolocation page
           MobileElement geo = (MobileElement) driver.findElement(MobileBy.id("com.lambdatest.proverbial:id/geoLocation"));
           geo.click();
           Thread.sleep(5000);

           //takes back to home page
           MobileElement el3 = (MobileElement) driver.findElementByAccessibilityId("Home");

           driver.navigate().back();
           Thread.sleep(2000);

           //Takes to speed test page
           MobileElement speedtest = (MobileElement) driver.findElement(MobileBy.id("com.lambdatest.proverbial:id/speedTest"));
           speedtest.click();
           Thread.sleep(15000);

           driver.navigate().back();

       } catch (AssertionError a) {
           ((JavascriptExecutor) driver).executeScript("lambda-status=failed");
           a.printStackTrace();
       }
// The driver.quit statement is required, otherwise the test continues to execute, leading to a timeout.
       driver.quit();
   }

}

I am going to share two screenshots from live running to give you guys a look and feel of scenarios running on an emulator. The left section of the screenshot shows the execution of commands on the command prompt and the right panel is the emulator on which the script is executing.

Scenario 1: Open the geolocation page (check the geolocation page on the emulator screen)

Scenario 2: Takes the speed of the test page. (check the speed of the test page on the emulator).

Debugging Steps for Common Errors in Appium

Make sure that before running the suite, the Android emulator is up and running. It’s useful to run adb kill-server && adb devices. This can reset the connection to the Android device, and the issue can be resolved.
If you’re running your Android emulator using Fastboot and the emulator isn’t being detected by ADB properly, try doing a cold boot: Android Studio > Tools > AVD Manager > Actions > Cold Boot Now. This will mostly solve all emulator issues (refer to Step 6) from the “Android Emulators for Appium testing” section to know how to cold boot.
For iOS, if the Instrument crashes when running against a physical device (“exited with code 253”), ensure Xcode has downloaded device symbols. Go to Window -> Devices, and then it should start automatically. It is needed after iOS version upgrades.
We need to ensure that the macOS keychain that holds the certificate required for building the app and the WebDriverAgent is unlocked. Especially when you are using ssh.

General symptoms to look for are codesign failures.

Appium may sometimes have difficulties finding the node executable if you’ve installed Node and npm via MacPorts. We need to make sure that the MacPorts bin folder (default path is : /opt/local/bin ) is added to PATH somewhere in ~/.profile, ~/.bash_profile or ~/.bashrc.
If you get an error “[INST STDERR] posix spawn failure; aborting launch” while running iOS tests, your app is not compiled correctly for the simulator or device.

Appium testing on Real Device Cloud

When we talk about Appium testing or try to figure out the real use of Appium then, in my past experiences, two things come to my mind: The first one is that it supports both Android automation testing and iOS automation testing, and the second one is that Appium is free and open source.

Remember that the learning curve for Appium testing is also quite easy, and you must have realized it by now if you are at the end of this post.

One important point to remember is that until now, we have run our test scripts using an emulator, but you must be wondering if I want to run on a real device cloud.

Do I need to buy an iPhone or Android phone? So the answer is NO. Now you must think, if we won’t buy a device, how can we test it? The answer is the buzzword “Cloud Devices.”

The best part is running our existing scripts on a real device is a cakewalk. Below, I will explain what changes to make if we opt for running our test on LambdaTest real device cloud. Here’s the walkthrough of the automated app testing on real devices using LambdaTest.

{% youtube _gC5igQyJf8 %}

You can also subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress E2E testing, CI/CD, and more.

Check this out: Run Automated Puppeteer Testing Online

You can use the same code that I have shared before but with the below changes:

Firstly let’s change the value of desired capabilities for parameters:

DesiredCapabilities capabilities = new DesiredCapabilities(); capabilities.setCapability("deviceName", "Galaxy S20"); capabilities.setCapability("platformVersion", "11"); capabilities.setCapability("platformName", "Android"); capabilities.setCapability("isRealMobile", true); capabilities.setCapability("app", "lt://APP10016551653068008326557"); //Enter app URL

2- Second change is to use Username and Password from LambdaTest and change Appium driver instance:

`
public static String userName = System.getenv("LT_USERNAME") == null ? "LT_USERNAME" //Add username here
: System.getenv("LT_USERNAME");
public static String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "LT_ACCESS_KEY" //Add accessKey here
: System.getenv("LT_ACCESS_KEY");

driver = new AppiumDriver(new URL("https://" + userName + ":" + accessKey + "@beta-hub.lambdatest.com/wd/hub"), capabilities);

`
3- If you want help for creating authentication or uploading your app to the real device provided by LambdaTest, you can refer to this Java with Appium documentation.

One thing we need to remember is that the scenarios are the same as used in the previous script using the emulator (open the geolocation page & take to speed test page). After all the changes are made on the vanilla_android class, the final piece of code will look like below:

`
import io.appium.java_client.AppiumDriver;
import io.appium.java_client.MobileBy;
import io.appium.java_client.MobileElement;
import io.appium.java_client.ios.IOSDriver;

import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.remote.RemoteWebDriver;
import java.net.MalformedURLException;
import java.net.URL;

public class vanilla_android {
    public static String userName = System.getenv("LT_USERNAME") == null ? "LT_USERNAME"  //Add username here
            : System.getenv("LT_USERNAME");
    public static String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "LT_ACCESS_KEY" //Add accessKey here
            : System.getenv("LT_ACCESS_KEY");
    private static AppiumDriver driver;

    public static void main(String args[]) throws MalformedURLException, InterruptedException {

        try {

            DesiredCapabilities capabilities = new      DesiredCapabilities();
            capabilities.setCapability("deviceName", "Galaxy S20");
            capabilities.setCapability("platformVersion", "11");
            capabilities.setCapability("platformName", "Android");
            capabilities.setCapability("isRealMobile", true);
            capabilities.setCapability("app", "lt://APP10016551653068008326557"); //Enter your app url
            capabilities.setCapability("deviceOrientation", "PORTRAIT");
            capabilities.setCapability("build", "Java Vanilla - Android");
            capabilities.setCapability("name", "Sample Test Java");
            capabilities.setCapability("console", true);
            capabilities.setCapability("network", false);
            capabilities.setCapability("visual", true);
            capabilities.setCapability("devicelog", true);
            driver = new AppiumDriver(new URL("https://" + userName + ":" + accessKey + "@beta-hub.lambdatest.com/wd/hub"), capabilities);
          //  driver = new AppiumDriver(new URL("http://localhost:4723/wd/hub"), capabilities);

            //Open the geolocation page
            MobileElement geo = (MobileElement) driver.findElement(MobileBy.id("com.lambdatest.proverbial:id/geoLocation"));
            geo.click();
            Thread.sleep(5000);

            //takes back to home page
            MobileElement el3 = (MobileElement) driver.findElementByAccessibilityId("Home");

              driver.navigate().back();
            Thread.sleep(2000);

            //Takes to speed test page
            MobileElement speedtest = (MobileElement) driver.findElement(MobileBy.id("com.lambdatest.proverbial:id/speedTest"));
            speedtest.click();
            Thread.sleep(15000);

            driver.navigate().back();

        } catch (AssertionError a) {
            ((JavascriptExecutor) driver).executeScript("lambda-status=failed");
            a.printStackTrace();
        }
// The driver.quit statement is required, otherwise the test continues to execute, leading to a timeout.
        driver.quit();
    }

}

4- Once you run it from the command line using the command shared in the “Appium testing with Demo Code” section:(mvn compile exec:java -Dexec.mainClass=vanilla_android -Dexec.classpathScope="test"), you can go to LambdaTest and check the execution report under Real Device section which will look like below:

The dashboard shown above has many features like screenshots, artifacts, logs, and execution videos. Now with the execution visible on the dashboard, we are done with running our tests on real devices!

Check this out: Agile Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

Conclusion:

In this mobile app testing tutorial, we deep-dived into the basics of the Appium framework for performing Android and iOS app testing with code demonstration. We also looked at running Appium tests on cloud grids like LambdaTest. Finally, we learned how to debug errors while running Appium tests and how to run Appium tests on real devices.

Remember, “Try and Fail but do not fail to try.” So try to run the tests with the demo code provided in this Appium tutorial, and we’ll be happy to hear your thoughts. You can use LambdaTest to test on Oppo & other mobile devices right from android to iPhone.

Happy Testing!

](url)

How To Automate iOS App Using Appium

Sidharth Shukla — Mon, 02 Jan 2023 14:02:49 +0000

Mobile apps have been an inseparable part of daily lives. Every business wants to be part of the ever-growing digital world and stay ahead of the competition by developing unique and stable applications.

Among all the mobile operating systems available in the market, current research states that iOS is the second most popular mobile operating system. There are some strong reasons behind it. Firstly, iOS is not restricted by any zonal or language barrier. Secondly, it supports 40 different languages, giving users a broader option globally.

According to the report, Apple sells nearly 200 Million iPhones annually, and Apple users download an average of 51 apps per minute. Developing an intuitive app is just half the battle won, as the second half can only be won if the app is fully functional and creates a lasting impression on the users. This is why rigorous iOS automation testing of apps becomes an absolute necessity!

To ensure that the iOS app runs flawlessly, you must ensure that mobile app testing is planned and executed perfectly. To achieve it, you need to use a framework like Appium to run iOS app testing on real iOS devices at scale. The result is wider coverage and faster execution with utmost quality.

This mobile app testing tutorial on performing Appium testing of iOS devices will help you answer all questions pertaining to how to automate iOS app using Appium.

Check this out: Black Box Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

Types of iOS application testing

There are specifically two types of iOS application testing, either you can test it using the simulator or by using the real device. In most real-time projects, the team prefers to perform regression testing in the iOS simulator, but simulator testing alone is insufficient for QA sign-off. This is why test (or QA) teams prefer to execute one round of Smoke or Sanity on the real devices.

When teams perform iOS testing, they like to run Functional Testing, Performance Testing, Security Testing, and Hardware Testing. It is important to note that Performance, Security, and Hardware Testing are non-functional testing types.

In this Appium testing tutorial, we will perform functional testing on iOS using a real device cloud.

Many mobile app testing frameworks facilitate automated device testing on iOS. However, my personal choice has always been “Appium.” You will know about the USPs of Appium once you read through this blog on how to automate iOS app using Appium.

Check this out: System Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

What is Appium?

Appium is an open source test automation framework for automating native, mobile web, and hybrid applications on iOS devices, Android devices, and Windows desktop platforms. Importantly, Appium is “cross-platform”: it allows you to write tests against multiple platforms (iOS, Android, Windows) using the same API.

In simple words, it processes the request from the client and forwards it to the simulator and emulator or real devices. The test scripts are automated, and the result is communicated to the client via the server. This emulator vs simulator vs real device testing blog will help you learn more about it.

This enables code reuse between iOS, Android, and Windows test suites. The best part is using programming languages such as JavaScript, Java, Ruby, Python, PHP, and C# for Appium test script design.

As per the official website of Appium, per month, around 416k downloads are done by the users. It has a massive number of users along with community support.

Watch this video to learn about Appium, one of the most popular open-source test automation frameworks for mobile app testing.

Check this out: Exploratory Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

Benefits of automating iOS app testing using Appium

As discussed earlier in this blog on how to automate iOS app using Appium, you must have had a little idea about iOS and Appium by now, but the million-dollar question is why Appium?

Appium has shown significant progress and is quickly becoming a preferred automation testing tool for mobile applications, with 35% of the organizations choosing it over other free/open source functional testing tools.

So, let’s point out some of the significant benefits of Appium for iOS app testing. We have alternatives for iOS automation, but Appium is easy to use and has extensive community support.

Cross platform

Appium is “cross-platform”. This means you can use the same tests across multiple platforms (iOS, Android, Windows). Not a single line of code change is required when using the APIs. This helps in making the test scripts more modular.

Avoid installing extra dependencies

From Appium 1.15.0, Appium communicates with a real device via appium-ios-device. You no longer have to install extra dependencies. The official documentation on appium-xcuitest-driver is also helpful in resolving dependencies

Support for major iOS versions

Appium supports major versions of iOS. iOS version 9.3 and above is supported by Apple XCUITest, and the lower to 9.3 version is supported by Apple’s UI Automator. Learn more about XCUITest through this XCUITest testing tutorial.

Avoid recompilation of app

Appium does not require recompilation of App. It means we don’t need to implement a thing in the application code. While other frameworks need you to implement some change inside your code. It simply means there is no need to open the project in XCode. Just use the .app file to automate the application

Hassle-free execution

Appium supports real devices cloud testing and testing on simulators and emulators. It gives the flexibility to execute the automation suite across the platforms.

In case you are a beginner to Appium you can learn to perform mobile app testing easily through this tutorial.

As stated on the official website of Appium, the Appium team does not test the XCUITest driver against jailbroken devices, so it cannot be guaranteed that it will work as seen on non-jailbroken devices.

Automate your iOS apps on the Appium cloud of 3000+ real devices. Try LambdaTest Now!

Prerequisites for how to automate iOS app using Appium

Before starting the pre-setup, as per my past experiences, I must tell you that it is quite tedious to do the entire setup, so please stay with us and follow all the steps carefully. Remember that all the steps mentioned below are mainly specific to OS, so follow steps respective to your operating system (i.e., macOS, Windows).

First, you must have the Java setup done along with an IDE. We can use any IDE, but I recommend using Eclipse or IntelliJ IDE. I would recommend using Eclipse for the first try or practice.
To set up JDK in the machine, please refer to the official Oracle website. If you already have JDK in your machine, skip this step. Never forget to check your java version in your machine post installation. You can also check the Java version as below once the installation is completed:

3- Once your JDK installation along with environment setup is done, the next step is supposed to install Eclipse. For your help, please refer to these blogs on how to install Eclipse and how to install IntelliJ.

You can also subscribe to the LambdaTest YouTube Channel and stay updated with the latest tutorials around Selenium testing, Cypress E2E testing, CI/CD, and more.

Step 1: Install Homebrew

It is a package management software, and to install, follow the instructions on this page: https://brew.sh/.

To check the installed details along with the version, we can type “brew -v” as shown below:

Step 2: Install Carthage

The WebDriverAgent requires it. To install it, just type below command:

 brew install carthage

If it is already installed in your machine, then you will get a message as below:

“carthage 0.38.0 is already installed and up-to-date.”

Step 3: Install Node & Npm

This step is required because Appium is a node application. To install it, run the below command on the terminal.

    brew install node

To verify the installed versions of npm and node, we can use npm -v & node -v as shown below:

Step 4: Install authorize-ios

authorize-ios is a little utility that pre-authorizes Instruments to run UIAutomation scripts against iOS devices. It is required to run tests on real devices.

In the terminal, enter the below command to install authorize-ios:

npm install -g authorize-ios

Step 5: Install ios-deploy

Install ios-deploy via Homebrew by running the below command on the terminal:

   brew install ios-deploy

To verify the installation, we can use ios-deploy –version command in the terminal as below:

Step 6: Install ideviceinstaller

This is the tool for managing apps on iOS device

    brew install ideviceinstaller

To check the installation is completed or not, ideviceinstaller –version command can be used as shown below:

Step-7: Install Xcode

Xcode is a complete developer toolset for creating apps for Mac, iPhone, iPad, Apple Watch, and Apple TV. Xcode brings user interface design, coding, testing, debugging, and submitting to the App Store into a unified workflow.

For step-by-step guidance on using Xcode to build, test, and submit apps to the App Store, look at XCode documentation. To verify the Xcode installation, we can use the /usr/bin/xcodebuild -version command as shown below:

Step 8: Install XCUITest driver

Appium XCUITest driver is a combined solution, which allows automated black-box testing of iOS and tvOS native applications and WebKit web views. The native testing is based on Apple’s XCTest framework and the fork of Facebook’s WebDriverAgent server.
Web views communication is done via Webkit remote debugger protocol.

The appium-ios-device library ensures real device communication. To install the XCUITest driver, please use the official website. It has the help doc, which can be referred to for common errors or issues faced during the installation.

Step 9: Install Appium and Appium Doctor

To install Appium, please type the below command and use the version of Appium after @ in the below command:

  npm install -g appium@version

You can check the version of Appium installed by using the command appium –version on the terminal, refer the below screenshot for reference:

Appium doctor is a mini software that checks all (well, almost all) of the preconditions for appium to run successfully. In the terminal, enter the following:

   npm install -g appium-doctor

We can use the command appium-doctor –version to check the installed version:

Step 10: Install Maven

As we all know, Maven is the dependency management tool, type below command in your terminal:

  brew install maven

Don’t forget the setup maven path before checking the version, you can do that by using below command:

   export PATH=/opt/apache-maven-3.8.6/bin:$PATH

Once installation complete do cross-check by typing below command:

  mvn — version

Output will look as below:

Step 11: Install TestNG

TestNG is a testing framework that we’ll be using to manage our automated test suite. Launch Eclipse, select “Help” > “Eclipse Marketplace”–>search for TestNG. Learn more about TestNG through this Selenium TestNG tutorial.

We should be able to see the TestNG for Eclipse option with a button as “Install.” Click on the button and complete the installation. For more help, please go through this Appium with TestNG tutorial.

Step 12: Install Appium Desktop

We need to install Appium Desktop so we can use the Appium Inspector to identify the elements on the iOS app for designing test scripts. You can install the Appium Desktop from the official website.

Capabilities setup for real iOS device

This is the most vital step to perform. Below are the mentioned capabilities we require to run our tests.

        DesiredCapabilities capabilities = new DesiredCapabilities();
        capabilities.setCapability("platformName", "iOS");
        capabilities.setCapability(MobileCapabilityType.NO_RESET, true);
        capabilities.setCapability("useNewWDA", false);
        capabilities.setCapability("platformVersion", "12.0.1");
        capabilities.setCapability("deviceName", "iPhone 8");
        capabilities.setCapability("udid", "auto");
        capabilities.setCapability("bundleId", "<your bundle id>");
        capabilities.setCapability("xcodeOrgId", "<your org id>");
        capabilities.setCapability("xcodeSigningId", "iPhone Developer");
        capabilities.setCapability("updatedWDABundleId", "<bundle id in scope of provisioning profile>");
        capabilities.setCapability(MobileCapabilityType.APP, "[PATH_TO_YOUR_IPA_FILE]");

Now the question is how to get the details that have been mentioned in the above code. Let’s go through them one by one:

platformVersion: is the version of iOS our app is running, 12.0.1 in my case.
deviceName: is not required, as we have plugged in a real device and will select that device using the udid desired capability. Appium still requires us to supply a value for deviceName, so we use iPhone 8. To know the device name, in the iPhone, we can navigate to“Settings> General > About > Name.”
udid: is the unique ID of the device we want to run our test on. Now connect your iPhone to your computer by USB and load up iTunes. We could find our device udid by running the command instruments -s devices in the terminal. Still, since we only have a single device plugged in, we can put in auto, and Appium will automatically find the udid of the device for us and use it. If ”auto” doesn’t work, then do provide your udid.
xcodeOrgId & xcodeSigningId: join the Apple Developer Program and locate your apple developer team id; xcodeorgid is the ID of the developer team that signed the certificate used to create the app. xcodeSigningId is the first part of the “Common Name” associated with the developer certificate.
Since XCode set this up for us, it is almost always iPhone Developer, but it could be something different for you if you are automating a different iOS device.
bundleID: it is the special iOS-internal name of our app. The easiest way to get the bundleID is by using iTunesConnect. The steps are as below:

Log into iTunes Connect.
Click My Apps.
Click on an app to find the bundle ID.
The default app page will open, displaying the App ID and bundle ID.

App: many websites provide the sample apk, which can be used for testing. If you do not have any .apk or .ipa files, you can run your sample tests on LambdaTest using our sample 🔗 iOS app.
noReset: do not forget to use this capability. This approximately saves 2.9 seconds per test by avoiding app installation before every test run.
updatedWDABundleId: we need to create a provisioning profile for signing the WebDriverAgentRunner. Launch the Xcode and create a new project, select the team and enter the project name as follows:

Take a look at the “Project” tab of your project settings to confirm that “Automatically manage signing” is selected, and an Xcode Managed Profile is created.

Suppose you manually try to run the WebDriverAgentRunner app on the device. In that case, you will see a popup message:

You can go to Settings => General => Device Management on the device to trust the developer and allow the WebDriverAgentRunner app to be run.

Copy your bundleId and add the following capability to your Appium Capabilities setup:

   capabilities.setCapability(“updatedWDABundleId”, “<bundle id in scope of provisioning profile>”);

If you are unable to do the above steps, then the manual configuration can also be done. To go through the steps, please refer to this document. It has all the steps along with the screenshots.

Check this out: UI Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

Identifying the iOS elements

In this section of this blog on how to automate iOS app using Appium, we will learn how to identify the iOS elements. To identify elements in iOS devices, we need to download and install the Appium Desktop application and use the Appium Desktop Inspector functionality.

If you have installed Appium Desktop, then we can start by clicking on the Start Server button inside of Appium Desktop as shown below.

2- Click the search icon from the right-up corner.

Add correct desired capabilities per your device/emulator and application. Then click on the Start Session button.

5- You can provide a .ipa file in desired capabilities inside Appium Inspector, which will install and launch the app. Refer to the screenshots below, which we have used to test .ipa and passed in the value against “app.” Use all the fields of desired capabilities discussed in this blog on how to automate iOS app using Appium. The best thing about the Appium Inspector is that you can verify your written locator on screen. Check the below screenshots.

6- If your locator is correct, it will highlight the associated element, which is the same for Android and iOS.

Some of the most used locator strategies are mentioned below.

STRATEGY	DESCRIPTION
Accessibility ID	Reads a unique identifier for a UI element. For XCUITest, it is the element’s accessibility-id attribute. For Android, it is the element’s content-desc attribute.
Test that you can filter for an item on the filter box.	For iOS, it is the full name of the XCUI element and begins with XCUIElementType. For Android, it is the full name of the UIAutomator2 class (e.g., android.widget.TextView)
ID	Native element identifier. resource-id for Android; name for iOS.
Name	Name of element.
XPath	Searches the app XML source using xpath (not recommended, has performance issues).
Image	Locates an element by matching it with a base 64 encoded image file.
iOS UIAutomation	When automating an iOS application, Apple’s Instruments framework can be used to find elements.

In most real time projects, one public webelement is created, and element identification for Android and iOS is mentioned, as shown below. The nameOfMobileElement mentioned below is just an example. You can replace the same with the name of the locator used to identify the webelement of the targeted mobile app. We have identified the iOS element using iOSNsPredicate.

        @iOSXCUITFindBy(iOSNsPredicate = "name=='<nameOfMobileElement>'")
        @AndroidFindBy(uiAutomator = "text(\"<textOf TheMobileElement>\")")
        public MobileElement elementName;

We can also use XPath as mentioned below for identification in iOS, in-fact all type of axes methods in XPath can be used to identify the element uniquely:

            @iOSXCUITFindBy(xpath = "//*[@name='<nameOfMobileElement>']/following-sibling::XCUIElementTypeStaticText")

Though in my past experiences the most used identification I have used is accessibility as below, “GO TO APP” is just an example, it should be replaced with the accessibility for the app used for testing:

   @iOSXCUITFindBy(accessibility = “GO TO APP”)

While identifying iOS elements, we need to remember that the element should always be unique and try the locators first and give XPath identification the least priority. I would suggest not using XPath locators unless there is no other alternative.

In general, XPath locators might be much slower than other locators like accessibility id, class name, and predicate (up to 100 times slower in some special cases). They are so slow because Apple’s XCTest framework does not natively support the XPath location.

Check this out: Agile Testing Tutorial: A Comprehensive Guide With Examples and Best Practices

Demo Code for automating iOS app using Appium

Before running the tests, we need to perform below two steps:

Step 1: Make sure the device which will be used for testing is unlocked, and if it asks you to “Trust the Computer”, tap the button to trust our Mac. You’ll need to do this the first time, and it won’t ask for it.

Step 2: Start the Appium server.

  import io.appium.java_client.MobileBy;
    import io.appium.java_client.MobileElement;
    import io.appium.java_client.ios.IOSDriver;
    import java.net.MalformedURLException;
    import java.net.URL;

    import io.appium.java_client.remote.MobileCapabilityType;
    import org.junit.Before;
    import org.junit.Test;
    import org.openqa.selenium.remote.DesiredCapabilities;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.openqa.selenium.support.ui.WebDriverWait;

    public class iOS_Test {
        private IOSDriver driver;

        @Before
        public void setUp() throws MalformedURLException {
            DesiredCapabilities capabilities = new DesiredCapabilities();
            capabilities.setCapability("platformName", "iOS");
            capabilities.setCapability("platformVersion", "15.5");
            capabilities.setCapability("deviceName", "Sidiphone");
            capabilities.setCapability("udid", "auto");
            capabilities.setCapability("bundleId", "<your bundle id>");
            capabilities.setCapability("xcodeOrgId", "<your org id>");
            capabilities.setCapability("xcodeSigningId", "iPhone Developer");
            capabilities.setCapability("updatedWDABundleId", "<bundle id in scope of provisioning profile>");
            capabilities.setCapability(MobileCapabilityType.APP, "[PATH_TO_YOUR_.IPA_FILE_COMPILED]");
            driver = new IOSDriver<>(new URL("http://localhost:4723/wd/hub"), capabilities);
        }

        @Test
        public void testClickAnElement() throws InterruptedException {
            //Opens the browser
            MobileElement browser = (MobileElement) driver.findElementByAccessibilityId("Browser");
            browser.click();
            Thread.sleep(3000);

            WebDriverWait el7 =  new WebDriverWait(driver, 30);
            el7.until(ExpectedConditions.elementToBeClickable(MobileBy.id("url")));
            driver.findElementById("url").sendKeys("https://www.lambdatest.com/");

            //Clicks on the text box
            WebDriverWait el = new WebDriverWait(driver,90);
            MobileElement el4 = (MobileElement) driver.findElementByAccessibilityId("find");
            el.until(ExpectedConditions.elementToBeClickable(el4));
            el4.click();
            el4.sendKeys("LambdaTest");

            //((JavascriptExecutor) driver).executeScript("lambda-status=passed");
            driver.quit();

        }
    }

In the above code, the Test method we have used is testClickAnElement(), and the element we are trying to click is from the iOS app shared in this post on how to automate iOS app using Appium.

Troubleshooting Tips

Make sure UDID is correct by checking it in XCode Organizer or iTunes. It is a long string (approx 20+ chars).
Make sure the following settings are enabled on your device:

A. Settings -> Developer -> Enable UI Automation
B. Settings -> Safari -> Advanced -> Web Inspector and Remote

3- Consider generating a provisioning profile with a .xctrunner identifier if you do not want to generate a wildcard one for manual configuration. The .xctrunner config support has been added since XCode 11.

4- Make sure the provisioning profile has an iOS Distribution certificate. An active XCode/xcodebuild connection/session is necessary to interact with WebDriverAgentRunner because of Apple’s security design. The certificate affects the limitation.

5- The keyboard preference in the device under test is Apple’s official one, and the input language is set to English to send texts to XCUIElementTypeSecureTextField, as Non-official or non-English keyboards may not be able to send keys to XCUIElementTypeSecureTextField.

Limitations

Given that Appium uses instruments underneath, we have all of the limitations of using Apple’s automation framework. This includes:

A slower response time between actions, automation that can only run over a USB tether, and only one device can execute automation simultaneously per host.
Each physical device or simulator requires a separate host running on a Mac to communicate with each device. This is due to the hosts being the one who determines where the commands are communicated, regardless of what parameters are passed into the automation. This may be a bug in the Appium infrastructure or requires a special command to determine the device to execute from the automation code.
The Instruments log files are not returned as part of the test, and the data given back to the running test is much less than what is seen in a typical Instruments test case.

How to automate iOS app using Appium on a real device cloud?

In this blog on how to automate iOS app using Appium, you must have realized that testing on real devices is not a cakewalk, especially iOS real device testing is tedious. The important thing is that real iOS device testing can only take place on a Mac, so we can’t even perform real iOS device testing without a Mac.

As a result, most organizations prefer to use real cloud devices for testing. You can try LambdaTest cloud devices, which are quite easy to use, and we can avoid setting up all the prerequisites on local machines.

LambdaTest provides a cloud-based solution for mobile automation testing. It lets you automate native and hybrid mobile apps on an online device farm of 3000+ real iOS. It is a scalable, secure, and high-performing Appium testing platform that empowers development and testing teams to accelerate their release cycles.

Below we have executed the test suite using LambdaTest real cloud devices. Just use the below code along with your username and password. We used the iPhone 12 for our test run. You can use the model as per the requirement.

    import io.appium.java_client.AppiumDriver;
    import io.appium.java_client.MobileBy;
    import io.appium.java_client.MobileElement;
    import io.appium.java_client.ios.IOSDriver;

    import org.openqa.selenium.remote.DesiredCapabilities;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.openqa.selenium.support.ui.WebDriverWait;

    import java.net.URL;

    public class vanilla_ios {

        public static String userName = System.getenv("LT_USERNAME") == null ? "sidharth****"  //Add username here
                : System.getenv("LT_USERNAME");
        public static String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "********" //Add accessKey here
                : System.getenv("LT_ACCESS_KEY");

        public static final String URL = "https://" + userName + ":" + accessKey + "@beta-hub.lambdatest.com/wd/hub";
        public static IOSDriver driver = null;

        public static void main(String[] args) throws Exception {

           try {
                DesiredCapabilities caps = new DesiredCapabilities();
                caps.setCapability("platformVersion", "15");
                caps.setCapability("deviceName", "iPhone 12");
                caps.setCapability("isRealMobile", true);
                caps.setCapability("app", "******"); //Enter your app url
                caps.setCapability("platformName", "iOS");
                caps.setCapability("build", "Java Vanilla - iOS");
                caps.setCapability("name", "Sample Test Java");
                caps.setCapability("devicelog", true);
                caps.setCapability("network", true);


            driver = new IOSDriver(new URL("https://" + userName + ":" + accessKey + "@beta-hub.lambdatest.com/wd/hub"), caps);


                Thread.sleep(2000);

                //Opens the browser
                MobileElement browser = (MobileElement) driver.findElementByAccessibilityId("Browser");
                browser.click();
                Thread.sleep(3000);

               WebDriverWait el7 =  new WebDriverWait(driver, 30);
               el7.until(ExpectedConditions.elementToBeClickable(MobileBy.id("url")));
               driver.findElementById("url").sendKeys("https://www.lambdatest.com/");

                //Clicks on the text box
                WebDriverWait el = new WebDriverWait(driver,90);
                MobileElement el4 = (MobileElement) driver.findElementByAccessibilityId("find");
                el.until(ExpectedConditions.elementToBeClickable(el4));
                el4.click();
                el4.sendKeys("Lambdatest");

                //((JavascriptExecutor) driver).executeScript("lambda-status=passed");
                driver.quit();

            } catch (Exception t) {
               System.out.println(t);
               driver.quit();

           }
        }
    }

In the above script, we have first done the capabilities setup and then automated the iOS app with two steps:

The first one is to open the browser and the second one is to click on the text box and then enter text “LambdaTest” on the text box. For ease of execution, we have used thread.sleep in this blog on how to automate iOS app using Appium. You can ignore the same while executing in your setup.

To execute the same, you need to use the below two commands on your terminal:

 mvn clean install

2- Once you execute the command, you should get the Build Success message as below:

After that, we need to execute the test cases using the below command on the terminal:

    mvn test -P ios

3- Once the above command executes successfully, we must go to the LambdaTest website and validate the runs. Navigate to the Real Device ⇒ App Automation Section. You should be able to see “Java Vanilla — iOS” as shown below:

4- Now click on the recent execution. You will be redirected to the build view page, where all the details about the execution will be displayed along with the video:

5- In the above, we can check the Test Logs and Network details. Isn’t it relatively easy to run the automation suite on real cloud devices compared to doing the entire setup on a local machine? The best part is selecting any iPhone model required for your testing.

Check this out: Jest Tutorial: Complete Guide to Jest Testing

Conclusion

With this, we have concluded this tutorial on how to automate iOS app using Appium. As per my suggestion, we should only consider real iOS devices for Sanity or Smoke suite execution. For regression, it is always advised to use either simulators or cloud devices.

Though we have simulators, we should never release a product without being tested on real devices, so better to prepare an automation suite and run the real devices on the cloud, saving time and ensuring quality.

We can address most app-related issues by ensuring that the app works on a real device. iOS testing with Appium will help provide that confidence in the product and confirm the app’s success when it is released to users.

Happy testing, and do share what should be the next topic you want to learn.