06 March

UI Testing .NET MAUI Apps with Appium: Setting Up a Reliable Cross-Platform Test Pipeline

By Jorge Perales Diaz MAUI

🚀 UI Testing .NET MAUI Apps with Appium: Setting Up a Reliable Cross-Platform Test Pipeline

Building modern mobile applications means delivering stable, predictable, and high-quality user experiences across multiple platforms. When working with .NET MAUI, developers gain the ability to target Android, iOS, Windows, and macOS from a single codebase. While this dramatically improves productivity, it also introduces a new challenge: 👉 Ensuring that the UI behaves consistently across all platforms. This is where UI automation testing becomes essential. Manual testing is slow, error-prone, and difficult to scale. Instead, automated UI tests allow teams to validate application behavior reliably and continuously. One of the most powerful tools for this purpose is Appium, a cross-platform automation framework built on the WebDriver protocol. In this guide, we will explore how to build a reliable cross-platform UI testing pipeline for .NET MAUI applications using Appium, covering everything from setup to continuous integration strategies.

🧠 Why UI Testing Matters in .NET MAUI

Unit tests validate business logic and backend behavior, but they cannot verify user interaction flows. Consider scenarios like:

  • Tapping buttons
  • Navigating between pages
  • Entering form data
  • Handling validation errors
  • Loading dynamic content
  • Platform-specific UI behavior

All of these interactions require UI-level validation. When building cross-platform applications with .NET MAUI, the same codebase renders UI through platform-specific handlers, meaning subtle differences can occur between: 📱 Android
🍎 iOS
🖥 Windows Automated UI tests help detect these inconsistencies early.

⚙️ Why Choose Appium?

Appium is one of the most widely adopted mobile automation frameworks because it provides: ✅ Cross-platform support
✅ WebDriver-based automation
✅ Integration with CI/CD pipelines
✅ Support for real devices and emulators
✅ Multiple programming languages (including C#) Most importantly for .NET developers, Appium integrates naturally with Selenium WebDriver, allowing tests to be written entirely in C#.

🏗 Architecture of a .NET MAUI UI Test Pipeline

A typical automated testing workflow looks like this:

Test Runner (xUnit / NUnit)
        ↓
Appium WebDriver Client
        ↓
Appium Server
        ↓
Platform Driver (Android / iOS)
        ↓
Device or Emulator
        ↓
.NET MAUI Application

Here is what each layer does: 🔹 Test Framework – Executes the automated tests
🔹 Appium WebDriver Client – Sends commands to Appium
🔹 Appium Server – Translates WebDriver commands to device actions
🔹 Platform Driver – Communicates with Android or iOS automation APIs
🔹 Device or Emulator – Runs the actual application under test This architecture allows UI tests to simulate real user behavior, including taps, gestures, and text input.

📦 Installing the Required Tools

Before writing tests, we need to install several dependencies.

1️⃣ Install Node.js

Appium runs on Node.js, so install it first:

https://nodejs.org

Verify installation:

node -v
npm -v

2️⃣ Install Appium

Install Appium globally using npm:

npm install -g appium

Verify installation:

appium --version

Start the Appium server:

appium

You should see something like:

Appium REST http interface listener started

3️⃣ Install Platform Drivers

Appium requires specific drivers for each platform.

Android Driver

appium driver install uiautomator2

iOS Driver

appium driver install xcuitest

🧪 Creating a .NET MAUI UI Test Project

UI tests should live in a separate project from the application itself. Example solution structure:

MyMauiApp
│
├── MyMauiApp
│   └── .NET MAUI Application
│
└── MyMauiApp.UITests
    └── Appium Test Project

Create the test project:

dotnet new xunit -n MyMauiApp.UITests

📚 Required NuGet Packages

Install the following packages:

Appium.WebDriver
Selenium.WebDriver
Selenium.Support
xunit
xunit.runner.visualstudio

🧑‍💻 Writing Your First UI Test

Let’s write a simple UI test that verifies whether a login button appears on the screen. Example using AndroidDriver:

using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;
using Xunit;

public class LoginTests
{
    private AndroidDriver driver;

    public LoginTests()
    {
        var options = new AppiumOptions();
        options.PlatformName = "Android";
        options.DeviceName = "Android Emulator";
        options.AutomationName = "UiAutomator2";
        options.App = "/path/to/app.apk";

        driver = new AndroidDriver(
            new Uri("http://127.0.0.1:4723"),
            options);
    }

    [Fact]
    public void LoginButton_ShouldBeVisible()
    {
        var loginButton = driver.FindElementByAccessibilityId("LoginButton");

        Assert.NotNull(loginButton);
        Assert.True(loginButton.Displayed);
    }
}

This test performs the following steps: 1️⃣ Launches the app
2️⃣ Locates a UI element using AccessibilityId
3️⃣ Verifies that the element is visible

🏷 Best Practice: Use AutomationId in MAUI

To make elements easily discoverable by UI tests, assign AutomationId values in your MAUI UI. Example:

<Button
    Text="Login"
    AutomationId="LoginButton"/>

This allows Appium to locate elements reliably across platforms.

📱 Running Tests on Android Emulator

Start the emulator first:

emulator -avd Pixel_6_API_34

Then run the tests:

dotnet test

Appium will automatically launch the application and execute the UI interactions.

🍎 Running Tests on iOS Simulator

For iOS testing, ensure that:

  • Xcode is installed
  • The simulator is available
  • WebDriverAgent is configured

Example configuration:

options.PlatformName = "iOS";
options.DeviceName = "iPhone 15";
options.AutomationName = "XCUITest";
options.App = "/path/to/app.app";

🔄 Building a Reliable Test Pipeline

A professional UI testing setup should include: ✔ Local development testing
✔ Emulator testing
✔ CI pipeline automation
✔ Device farm execution

🧩 Integrating Tests into CI/CD

A typical pipeline might look like this:

Code Commit
     ↓
Build .NET MAUI App
     ↓
Launch Emulator
     ↓
Start Appium Server
     ↓
Run UI Tests
     ↓
Publish Test Results

Example using GitHub Actions:

- name: Install Appium
  run: npm install -g appium

- name: Start Appium
  run: appium &

- name: Run Tests
  run: dotnet test

⚡ Strategies for Reliable UI Tests

UI automation can become flaky if not designed carefully. Follow these best practices:

Use Explicit Waits

Avoid timing issues by waiting for elements.

var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
var button = wait.Until(d => d.FindElement(By.AccessibilityId("LoginButton")));

Avoid Absolute XPath

Prefer stable selectors: ✔ AccessibilityId
✔ ResourceId
✔ Test tags

Isolate Test Data

Ensure each test runs independently to avoid state conflicts.

📊 Monitoring Test Stability

UI pipelines should track: 📈 Pass rates
📉 Flaky test frequency
⏱ Test execution time Tools such as:

  • Azure DevOps
  • GitHub Actions
  • Test reporting dashboards

help teams identify unstable tests quickly.

🧭 Final Thoughts

Automated UI testing is essential for delivering high-quality cross-platform applications. With .NET MAUI and Appium, developers can build a reliable test pipeline that validates real user interactions across Android, iOS, and Windows. By combining: ✔ Strong automation practices
✔ Stable element selectors
✔ CI/CD integration
✔ Cross-platform device testing teams can ensure that their applications remain stable, consistent, and production-ready. While setting up UI automation requires initial effort, the long-term payoff is enormous: faster releases, fewer regressions, and a far more confident development process. As cross-platform development continues to evolve, integrating robust UI testing strategies will remain a critical pillar of modern mobile engineering. Happy testing! 🧪📱🚀


An unhandled error has occurred. Reload 🗙