Comparing 3 Flutter Testing Tools on the Same Sample App

so i was looking into mobile testing for Flutter and kept seeing the same three names pop up: Patrol, Maestro, and Appium. all of them can test Flutter apps, but they feel quite different from each other.

my first reaction was: which one should i actually use? they all support iOS and Android, so what is even the difference?

i decided to stop comparing them on paper and just try all three on the same real app: my-demo-app-flutter from Sauce Labs. it is a simple Flutter counter app, which makes it perfect for a fair comparison. same test scenario, three different tools, and let’s see what happens.

the app we are testing

the Sauce Labs Flutter demo app is a counter app built with Flutter. it has:

• an increment (+) button
• a decrement (-) button
• a counter display that shows the current value

simple enough to be a good benchmark. the goal for our test: open the app, increment 5 times, decrement 3 times, verify the final value is 2.

to follow along, clone the repo:

git clone https://github.com/saucelabs/my-demo-app-flutter.git
cd my-demo-app-flutter
flutter pub get

quick intro to each tool

Patrol is built specifically for Flutter. it uses Dart (same language as your app) and supports grey-box testing, meaning it can interact directly with the Flutter widget tree, not just the rendered pixels. it also handles native stuff like permission dialogs and Wi-Fi settings natively.

Maestro is probably the easiest to get started with. you write tests in YAML, no code needed. it is built for mobile-first testing and is especially strong when you need to test flows that jump between multiple apps.

Appium (with the Flutter Integration Driver) is the veteran. it lets you write tests in Java, Python, or JavaScript. powerful and platform-agnostic, but it requires more setup. the integration_test/appium_test.dart file in the repo is actually the bridge that makes Appium speak Flutter.

comparison table

multi-app support: a special mention

if your test flow needs to jump between apps, this is where they really differ:

the exercise: same test, three different tools

the test scenario for all three: open the app, tap increment 5 times, tap decrement 3 times, verify the counter shows 2.

tool 1: Appium with Flutter Integration Driver

this is the most interesting one because the Sauce Labs repo already includes the bridge file at integration_test/appium_test.dart. this file initializes the Appium Flutter server inside the app, which lets Appium find and interact with Flutter widgets.

step 1: check the appium_test.dart (already in the repo)

// integration_test/appium_test.dart
import 'package:appium_flutter_server/appium_flutter_server.dart';
import 'package:my_demo/main.dart' as app;

void main() {
  initializeTest(app: app.MyApp());
}

that is the whole file. it just registers the app with the Appium Flutter server. not much code but a lot happening under the hood.

step 2: add the dependency to pubspec.yaml

dev_dependencies:
  integration_test:
    sdk: flutter
  flutter_test:
    sdk: flutter
  appium_flutter_server: ^0.0.16

step 3: build the app with the appium_test.dart target

for Android:

cd android
gradle wrapper
./gradlew app:assembleDebug -Ptarget=`pwd`/../integration_test/appium_test.dart

for iOS simulator:

flutter build ios integration_test/appium_test.dart --simulator

step 4: write the actual test (in JavaScript/Node.js)

// test/counter.test.js
const { remote } = require('webdriverio');

const capabilities = {
  platformName: 'Android',
  'appium:deviceName': 'emulator-5554',
  'appium:app': './build/app/outputs/flutter-apk/app-debug.apk',
  'appium:automationName': 'FlutterIntegration',
};

async function main() {
  const driver = await remote({
    hostname: 'localhost',
    port: 4723,
    capabilities,
  });

  // wait for app to be ready
  await driver.pause(2000);

  // increment 5 times
  for (let i = 0; i < 5; i++) {
    const incrementBtn = await driver.$('~increment_button');
    await incrementBtn.click();
    await driver.pause(300);
  }

  // decrement 3 times
  for (let i = 0; i < 3; i++) {
    const decrementBtn = await driver.$('~decrement_button');
    await decrementBtn.click();
    await driver.pause(300);
  }

  // verify counter shows 2
  const counterText = await driver.$('~counter_text');
  const value = await counterText.getText();
  console.log('Final counter value:', value); // expected: 2

  await driver.deleteSession();
}

main().catch(console.error);

step 5: run it (Appium server must be running)

# terminal 1: start appium server
appium

# terminal 2: run the test
node test/counter.test.js

what you will notice right away: you need to start the Appium server separately, manage capabilities, and the setup involves several moving parts before you even write a single test assertion.

tool 2: Patrol

Patrol writes tests in Dart, right next to your app code. it can reach inside the Flutter widget tree using semantic labels or widget finders.

step 1: add patrol to pubspec.yaml

dev_dependencies:
  patrol: ^3.0.0
  integration_test:
    sdk: flutter

step 2: install patrol CLI

dart pub global activate patrol_cli

step 3: write the test

// integration_test/counter_patrol_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:patrol/patrol.dart';
import 'package:my_demo/main.dart' as app;

void main() {
  patrolTest('increment 5 times, decrement 3 times, verify 2', ($) async {
    app.main();
    await $.pumpAndSettle();

    // increment 5 times
    for (var i = 0; i < 5; i++) {
      await $.tap(find.byTooltip('Increment'));
      await $.pumpAndSettle();
    }

    // decrement 3 times
    for (var i = 0; i < 3; i++) {
      await $.tap(find.byTooltip('Decrement'));
      await $.pumpAndSettle();
    }

    // verify counter is 2
    expect(find.text('2'), findsOneWidget);
  });
}

step 4: run it

patrol test

notice how you are writing Dart, exactly like your app code. the $ object gives you access to native device interactions too if you need them later.

tool 3: Maestro

Maestro needs no Dart and no Node.js. you just describe your test steps in YAML and run it.

step 1: install Maestro CLI

curl -Ls "https://get.maestro.mobile.dev" | bash

step 2: write the test

# counter_test.yaml
appId: com.saucelabs.mydemoappflutter
---
- launchApp
- assertVisible: "0"

# increment 5 times
- tapOn:
    id: "increment_button"
- tapOn:
    id: "increment_button"
- tapOn:
    id: "increment_button"
- tapOn:
    id: "increment_button"
- tapOn:
    id: "increment_button"

# decrement 3 times
- tapOn:
    id: "decrement_button"
- tapOn:
    id: "decrement_button"
- tapOn:
    id: "decrement_button"

# verify final value
- assertVisible: "2"

step 3: run it (device or emulator must be running)

maestro test counter_test.yaml

that is it. no server to start, no changes to your Flutter project, no Dart or JS code. just a YAML file and one command.

what i noticed after running all three

Appium took the most setup time. you need to install Appium, install the Flutter Integration Driver plugin, make sure the app is built with the right target (appium_test.dart), and start the server separately. the integration_test/appium_test.dart file in the repo is very small but it is a critical piece that is easy to miss. once it all runs though, it works, and you can write tests in whatever language your team prefers.

Patrol felt the most natural if you already know Flutter. writing tests in Dart next to your app code just makes sense. the grey-box access to widgets means your locators are more stable and less likely to break from UI changes. setup is a bit more than Maestro but nothing overwhelming.

Maestro won on speed of getting started. no project changes needed, just write YAML and run. the downside is it only sees what is rendered on screen, not the widget tree, so if a widget does not have a proper semantic label, Maestro will struggle to find it.

so which one should you pick?

honestly it depends on your situation but here is my simple take:

if you are just starting out or want to write tests fast with minimal setup: go with Maestro. YAML is easy, flakiness is very low, and you can start in minutes without touching your Flutter project.

if you are building a Flutter-heavy app and need deep widget-level control, permission handling, or system-level interactions: go with Patrol. it understands your app from the inside and everything is in Dart.

if your team already has Appium experience or needs tests in a non-Dart language (Java, Python, JS): Appium with the Flutter Integration Driver is worth learning. the integration_test/appium_test.dart bridge is the key piece, and you get the full Appium ecosystem on top of it. just be prepared for more moving parts.

i am still learning flutter apps mobile automation test by myself, so cmiiw if something here is off. feel free to drop your experience in the comments, especially if you have tried any of these on a real production app.

This article was written with AI support to make research faster and help structure ideas and code more clearly.

cmiiw 🙏🏼

hanupis 🙏🏼

disclaimer: dependency versions and API details can change, always check the official docs for the latest. the code above is based on the my-demo-app-flutter v1.0.0 release. widget key names may differ if the repo updates.

references:

• my-demo-app-flutter repo: https://github.com/saucelabs/my-demo-app-flutter
• Appium Flutter Integration Driver: https://github.com/AppiumTestDistribution/appium-flutter-integration-driver
• Sauce Labs Appium Flutter docs: https://docs.saucelabs.com/mobile-apps/automated-testing/appium/appium-flutter-integration-driver/
• Patrol docs: https://patrol.leancode.co
• Maestro docs: https://maestro.mobile.dev
• Flutter integration testing: https://docs.flutter.dev/cookbook/testing/integration/introduction