Introduction

What is XCUItest?

Key Features of XCUItest

1. Integration with Xcode: XCUItest is integrated into Xcode, Apple’s development environment, making it easy to write, run, and manage tests.
2. Accessibility Identification: It uses accessibility identifiers to locate and interact with UI elements, promoting good accessibility practices.
3. Automation: Automates user interactions like taps, swipes, and text entry, enabling thorough and repetitive testing.
4. Parallel Testing: Supports running tests on multiple devices simultaneously, speeding up the testing process.

Setting Up XCUItest

1. Create a New Xcode Project: Open Xcode and create a new iOS project. Choose a template, such as “Single View App,” and configure your project settings.
2. Add a UI Testing Target:
   • Go to your project settings in Xcode.
   • Click the “+” button at the bottom of the target list.
   • Select “iOS UI Testing Bundle” and click “Next.”
   • Name your testing target (e.g., “MyAppUITests”) and finish the setup.
3. Configure the Testing Target:
   • In the newly created testing target, open the MyAppUITests.swift file.
   • Import the XCTest framework and your app’s module.

Writing Your First XCUItest

• Add Accessibility Identifiers: In your main app target, assign accessibility identifiers to the UI elements you want to interact with. For example, in ViewController.swift:

@IBOutlet weak var myLabel: UILabel!
@IBOutlet weak var myButton: UIButton!

override func viewDidLoad() {
    super.viewDidLoad()
    myLabel.accessibilityIdentifier = "myLabel"
    myButton.accessibilityIdentifier = "myButton"
}

• Write the Test: In the MyAppUITests.swift file, write the test method:

import XCTest

class MyAppUITests: XCTestCase {
    
    override func setUpWithError() throws {
        continueAfterFailure = false
        let app = XCUIApplication()
        app.launch()
    }

    override func tearDownWithError() throws {
        // Code to execute after each test method
    }

    func testButtonTapChangesLabelText() throws {
        let app = XCUIApplication()
        let button = app.buttons["myButton"]
        let label = app.staticTexts["myLabel"]
        
        // Ensure the initial state is correct
        XCTAssertEqual(label.label, "Initial Text")
        
        // Perform the button tap
        button.tap()
        
        // Verify the label text changes
        XCTAssertEqual(label.label, "Button Tapped")
    }
}

• 1. Run the Test:
     • Select the MyAppUITests scheme.
     • Press Command-U to run the tests.
     • Xcode will build your app, launch it in the simulator, and execute the test.

Conclusion

What is Appium?

Prerequisites

1. macOS: Appium requires macOS to test iOS applications.
2. Xcode: Install the latest version of Xcode, which includes the iOS Simulator.
3. Appium Server: Download and install the Appium server from the official website or via npm (npm install -g appium).
4. Appium Desktop: (Optional) Install Appium Desktop, which provides a graphical interface for Appium.
5. Java Development Kit (JDK): Ensure you have JDK installed.
6. Integrated Development Environment (IDE): Use an IDE like IntelliJ IDEA, Eclipse, or Visual Studio Code for writing test scripts.
7. Node.js and npm: Install Node.js and npm, which are required for Appium installation.

Setting Up Desired Capabilities

Basic Desired Capabilities for iOS

1. platformName: The platform on which the application will be tested. For iOS, this should be set to "iOS".
2. platformVersion: The version of the iOS platform. Specify the version of iOS running on the simulator or device.
3. deviceName: The name of the iOS device or simulator. Common names include "iPhone 13", "iPad Pro (12.9-inch)", etc.
4. automationName: The automation engine used. For iOS, this is typically "XCUITest".
5. app: The path to the .app file of the iOS application to be tested.
6. udid: The unique device identifier of a real device. This is optional for simulators.

import io.appium.java_client.AppiumDriver;
import io.appium.java_client.ios.IOSDriver;
import org.openqa.selenium.remote.DesiredCapabilities;

import java.net.URL;

public class AppiumIOSSetup {
    public static void main(String[] args) {
        // Create a new instance of DesiredCapabilities
        DesiredCapabilities caps = new DesiredCapabilities();
        
        // Set the desired capabilities
        caps.setCapability("platformName", "iOS");
        caps.setCapability("platformVersion", "16.0");
        caps.setCapability("deviceName", "iPhone 13");
        caps.setCapability("automationName", "XCUITest");
        caps.setCapability("app", "/path/to/your.app");
        
        try {
            // Initialize the Appium driver
            AppiumDriver driver = new IOSDriver(new URL("http://localhost:4723/wd/hub"), caps);
            
            // Your test code here
            
            // Quit the driver
            driver.quit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Steps to Start iOS Testing with Appium

1. Install and Start Appium Server
   • Start the Appium server using the command line (appium) or Appium Desktop. Ensure the server is running on the default address http://localhost:4723.
2. Configure the Desired Capabilities
   • As shown in the sample code above, configure the desired capabilities to specify the test environment and the application details.
3. Write Your Test Script
   • Use your preferred programming language and IDE to write test scripts. The script should initialize the Appium driver with the specified desired capabilities.
4. Run Your Tests
   • Execute your test script. The Appium server will communicate with the iOS device or simulator, launching the application and performing the specified actions.
5. Analyze Results
   • Review the test results, logs, and reports generated by Appium. Identify any issues and refine your test cases as needed.

Conclusion

What is Appium Inspector?

Setting Up Appium Inspector for iOS

1. Install Appium Server: Download and install Appium from the official website.
2. Install Appium Desktop: Appium Desktop includes the Inspector tool. Download it from the Appium Desktop GitHub repository.
3. Configure Xcode and iOS Device:
   • Ensure Xcode is installed and configured.
   • Connect your iOS device or set up an iOS simulator.
   • Enable Developer Mode on your iOS device.

Launching Appium Inspector

1. Start Appium Server: Open the Appium Desktop application and start the server.
2. Configure Desired Capabilities: Define the desired capabilities for your iOS application. These are key-value pairs that specify the configurations needed for your Appium session. Below is an example of desired capabilities for an iOS device:

   {
     "platformName": "iOS",
     "platformVersion": "14.4",
     "deviceName": "iPhone 12",
     "app": "/path/to/your/app.app",
     "automationName": "XCUITest"
   }

3. Start a Session: Click on the “Start Session” button in Appium Desktop after entering the desired capabilities. This will launch the Appium Inspector with your iOS app.

Using Appium Inspector to Find XCUIElements

1. Navigate the UI:
   • The Inspector window will display the current screen of your application.
   • You can interact with the app directly through the Inspector, similar to how you would on an actual device.
2. Inspect Elements:
   • Click on elements in the mirrored app screen to select them.
   • The right-hand panel will display the properties of the selected element, including its XCUIElementType, accessibility ID, label, value, and XPath.
3. Extracting Locators:
   • Accessibility ID: Use the name attribute (often the accessibility ID) for locating elements.
   • XPath: Appium Inspector generates an XPath for the selected element. Copy this XPath for use in your test scripts.
   • Class Chain: Appium supports iOS Class Chain queries, which are faster than XPath for locating elements.

Using RobotQA Live Testing for Inspection

Overview of Appium

Appium is an open-source, cross-platform test automation tool that allows you to write tests for mobile applications on both iOS and Android using the same API. It supports various programming languages, including Java, JavaScript, Python, and Ruby, thanks to the WebDriver protocol.

Overview of XCTest

XCTest is a testing framework provided by Apple, specifically designed for iOS and macOS applications. It integrates seamlessly with Xcode, Apple’s integrated development environment (IDE), and supports both unit testing and UI testing.

Key Differences Between Appium and XCTest

1. Platform Support

• Appium: Cross-platform support for both iOS and Android. This makes Appium an excellent choice if you are developing applications for multiple platforms and want to maintain a single codebase for your tests.
• XCTest: Exclusive to Apple platforms (iOS, macOS, watchOS, and tvOS). XCTest is ideal if you are focused solely on iOS development and want deep integration with Apple’s ecosystem.

2. Programming Languages

• Appium: Supports multiple programming languages (Java, JavaScript, Python, Ruby, etc.), providing flexibility to use the language you are most comfortable with or that fits your tech stack.
• XCTest: Primarily uses Swift and Objective-C. While this ensures tight integration with your iOS application code, it might be a limitation if you prefer using other languages.

3. Integration and Setup

• Appium: Requires a bit more setup, as it involves installing and configuring the Appium server, as well as the necessary drivers for iOS (and Android if needed). This setup can be more complex and might require additional dependencies like Node.js.
• XCTest: Integrated into Xcode, making it easy to set up and use without any additional installations. Tests can be run directly from the Xcode IDE, providing a seamless development and testing experience.

4. Test Execution

• Appium: Can execute tests on real devices and simulators/emulators. Appium can be integrated with cloud-based testing platforms like Sauce Labs or BrowserStack to run tests on various device configurations.
• XCTest: Also supports testing on real devices and simulators. However, it benefits from tighter integration with Xcode, which can simplify the process of managing and executing tests. XCTest can be run on local machines or through Apple’s Continuous Integration service, Xcode Cloud.

5. Community and Support

• Appium: Large and active open-source community with extensive documentation, tutorials, and third-party integrations. You can find plenty of resources and support from other users and contributors.
• XCTest: Backed by Apple, with official documentation and support. While the community might not be as large as Appium’s, the resources provided by Apple are comprehensive and authoritative.

6. Features and Capabilities

• Appium: Supports a wide range of testing scenarios, including cross-platform tests, and provides features like the Appium Inspector for inspecting UI elements. Appium’s use of the WebDriver protocol allows for more flexibility in writing and managing tests.
• XCTest: Offers robust features for both unit and UI testing, with advanced capabilities like performance testing, UI recording, and code coverage metrics. XCTest’s tight integration with Xcode means you can leverage all of Xcode’s features, including debugging and profiling tools.

Use Cases

• Appium: Ideal for projects that require cross-platform testing or for teams that use multiple programming languages. Appium is suitable for scenarios where you need to write tests that can be reused across both iOS and Android applications.
• XCTest: Best suited for iOS-only projects where deep integration with Apple’s tools and ecosystem is a priority. XCTest is perfect for teams that are already working within Xcode and want a seamless testing experience.

Conclusion

Both Appium and XCTest have their own strengths and are suited to different needs. Appium’s cross-platform capabilities and support for multiple languages make it a versatile choice for diverse testing requirements. On the other hand, XCTest’s tight integration with Xcode and focus on Apple platforms provide a streamlined and efficient testing experience for iOS applications.

Choosing the right tool depends on your specific project requirements, development environment, and team expertise. By understanding the differences between Appium and XCTest, you can make an informed decision that aligns with your testing goals and ensures the quality of your iOS applications.   Feel free to leave comments or ask questions if you have any doubts or need further clarification.

Happy testing!

About WebdriverAgent 

Webdriver agent (WDA)  is an open-source project used for iOS automation testing by Appium. This project is responsible for actions ie. clicking, swiping, tapping. Initially started by Facebook (Github link), the project has been archived, and now the Appium team continues development in a new repo. We strongly recommend both installing WebDriverAgent manually before iOS testing and Appium WDA configuration. That is why Appium will attempt to install its own WDA inside node modules appium-xcuitest-driver/node_modules/appium-webdriveragent. So that, you have to configure WDA (the same steps of manual configuration) inside of Appium before testing.

How to Install WDA

Firstly, download the WDA Release package.

NOTE: Do not clone the repo. Sometimes, pre-release commits cause the unexpected behavior during testing.

After that, firstly we have to configure “Signing & Capabilities” of WebDriverAgentRunner and WebDriverAgentLib targets. Select your Team signing option and build the WebDriverAgentRunner project: Product–>Build For–>Testing.

Building WDA can be stressful and challenging. If you encounter any issues, please contact us, and we will share a blog about it.

Once the project build is finished, install WDA on your device. To install WDA, go to Product–>Perform Action–>Test Without Building option. This will install WDA to your device and start WDA server (default port is: 8100). You will see the “Automation Running” interface on your device screen, indicating that you have successfully configured and installed WDA on your phone. Do not forget to follow the same steps for Appium WDA appium-xcuitest-driver/node_modules/appium-webdriveragent. Now you are ready for Appium iOS testing. 

Happy Testing