Framework-Vergleich · 2026

Appium vs Espresso

Appium und Espresso sind die beiden führenden Wege, Android-UI-Tests zu automatisieren. Appium ist ein plattformübergreifendes Black-Box-Framework auf dem W3C-WebDriver-Protokoll; Espresso ist Googles schnelles White-Box-Framework, ausschließlich für Android. Dieser Leitfaden vergleicht sie direkt, mit Codebeispielen und einer Entscheidung, die Sie innerhalb von fünf Minuten umsetzen können.

Browser und Geräte
6100+
Cloud-Parallelität
100×
Verfügbarkeits-SLA
99.99%

Von diesen Unternehmen vertraut

30-Sekunden-Antwort

Welches sollten Sie wählen?

Appium Wählen Sie Appium, wenn…

Sie eine Testsuite wünschen, die sowohl auf Android als auch auf iOS läuft, Ihr Team in Java, Python, JavaScript, Ruby oder C# arbeitet oder Sie Apps testen, die Sie nicht mit Instrumentierung neu bauen können.

Espresso Wählen Sie Espresso, wenn…

Sie ausschließlich Android testen, Ihnen der App-Quellcode gehört und Sie die schnellsten, am wenigsten instabilen UI-Tests mit automatischer Synchronisierung wünschen, geschrieben in Kotlin oder Java neben Ihrer App.

Wählen Sie beide, wenn…

Sie Espresso für schnelle Android-only-Komponenten- und UI-Tests und Appium für eine plattformübergreifende End-to-End-Abdeckung nutzen. TestingBot führt beide auf demselben Echtgeräte-Raster aus, parallel.

Hintergrund

Was sind Appium und Espresso?

Zwei Frameworks zur mobilen UI-Automatisierung mit gegensätzlichen Designs. Das eine ist plattformübergreifend und Black-Box; das andere ist Android-nativ und White-Box.

Appium

Appium

Veröffentlicht 2012 · OpenJS Foundation · Apache 2.0

Appium ist ein quelloffenes, plattformübergreifendes Testframework für native, hybride und mobile Web-Apps. Es implementiert das W3C-WebDriver-Protokoll, sodass dieselbe Client-Bibliothek sowohl iOS als auch Android aus Java, Python, Node.js, Ruby, C# und mehr steuert.

Appium steuert die App von außen als Black-Box und benötigt daher keinen App-Quellcode. Auf Android nutzt es im Hintergrund den UiAutomator2- oder Espresso-Treiber; auf iOS nutzt es XCUITest. Diese Ebene macht einen Test plattformübergreifend wiederverwendbar.

  • Java / Python / Node.js / Ruby / C# / PHP
  • Plattformübergreifend, nativ, hybrid und mobiles Web
  • Black-Box, kein App-Quellcode erforderlich
Espresso

Espresso

Veröffentlicht 2013 · Google · Apache 2.0

Espresso ist Googles UI-Testframework für Android, Teil der Android-Jetpack-Testbibliotheken. Tests laufen In-Process auf dem Gerät, im selben Prozess wie die zu testende App, was ihnen direkten Zugriff auf die App und automatische Synchronisierung mit dem UI-Thread verschafft.

Da Espresso innerhalb des App-Prozesses läuft, ist es schnell und zuverlässig, mit sehr geringer Instabilität. Die Kompromisse: es ist ausschließlich für Android, es ist in Kotlin oder Java geschrieben und es benötigt einen instrumentierten Build der App.

  • Kotlin und Java
  • In-Process, automatische UI-Synchronisierung
  • Nur Android · benötigt einen instrumentierten Build
Direkter Vergleich

Appium vs Espresso: ein direkter Vergleich

Über alle Dimensionen hinweg, die für Android-UI-Tests und plattformübergreifende Abdeckung relevant sind.

Appium versus Espresso feature comparison
Dimension Appium Espresso
First release 2012 2013
Maintained by Open source (OpenJS Foundation) Google
Platforms iOS + Android Android only
Languages Java, Python, JS, Ruby, C#, PHP Java, Kotlin
Protocol W3C WebDriver Android instrumentation
Test execution Out-of-process (black-box) In-process (white-box)
Speed Slower (WebDriver round-trips) Very fast (in-process)
App source needed No (black-box) Yes (instrumented build)
UI synchronization Manual waits Automatic, built in
Cross-platform reuse Same test on iOS + Android Android only
Web / hybrid apps Yes Limited
Flakiness Good Excellent (tight coupling)
On TestingBot Upload app, WebDriver hub Upload app + test, CLI
Free for open source on TestingBot

Beide laufen auf den echten Android-Geräten und Emulatoren von TestingBot. Appium verbindet sich mit dem WebDriver-Hub über eine hochgeladene App; Espresso läuft über die TestingBot CLI.

Derselbe Anmeldetest

Anmelden unter Android

Ein Anmeldevorgang, gesteuert als Black-Box durch Appium und als White-Box durch Espresso. Beide laufen auf denselben echten Android-Geräten auf TestingBot.

Appium + Python test_login.py
# real Android device on TestingBot
from appium import webdriver
from appium.options.android import UiAutomator2Options
from appium.webdriver.common.appiumby import AppiumBy

opts = UiAutomator2Options().load_capabilities({
    'platformName': 'Android',
    'appium:app': 'tb://APP_ID',
    'tb:options': { 'realDevice': True },
})
d = webdriver.Remote('https://hub.testingbot.com/wd/hub', options=opts)
d.find_element(AppiumBy.ACCESSIBILITY_ID, 'username').send_keys('jane')
d.find_element(AppiumBy.ACCESSIBILITY_ID, 'sign_in').click()
assert d.find_element(AppiumBy.ID, 'welcome').is_displayed()
Espresso + Kotlin LoginTest.kt
// runs via the TestingBot CLI
@Test
fun loginRedirectsToDashboard() {
    onView(withId(R.id.username))
        .perform(typeText("jane@example.com"))
    onView(withId(R.id.password))
        .perform(typeText("secret"))
    onView(withId(R.id.sign_in))
        .perform(click())

    onView(withId(R.id.welcome))
        .check(matches(isDisplayed()))
}

Der Appium-Test verbindet sich mit dem WebDriver-Hub über eine hochgeladene App; die Espresso-Suite läuft über die TestingBot CLI. Beide laufen auf echten Android-Geräten.

Entscheidungsmatrix

Wann sollte man welche Option wählen?

Wählen Sie Appium, wenn

  • Sie eine Testsuite benötigen, die sowohl auf Android als auch auf iOS läuft, ohne Neuschreiben.
  • Ihr Team Java, Python, JavaScript, Ruby oder C# statt Kotlin schreibt.
  • Sie eine App testen, die Sie nicht mit Instrumentierung neu bauen können, oder eine Drittanbieter- oder Hybrid-App.
  • Sie bereits Selenium oder WebDriver nutzen und dasselbe Protokoll für Mobilgeräte wünschen.
  • Sie native, hybride und mobile Web-Flows mit einem Tool testen.
Appium auf TestingBot ausführen

Wählen Sie Espresso, wenn

  • Sie ausschließlich Android testen und Ihnen der App-Quellcode gehört, sodass ein instrumentierter Build in Ordnung ist.
  • Sie die schnellsten, am wenigsten instabilen UI-Tests mit automatischer Synchronisierung wünschen.
  • Ihr Team Kotlin oder Java schreibt und Tests neben dem App-Code wünscht.
  • Sie internen App-Zustand, benutzerdefinierte Views oder Komponenten testen, nicht nur die öffentliche UI.
  • Sie UI-Tests von Tag eins an als Teil des Android-Builds und der CI ausführen.
Espresso auf TestingBot ausführen
TestingBot unterstützt beides

Hören Sie auf zu wählen, führen Sie beide auf demselben Raster aus

Laden Sie Ihre App hoch und steuern Sie sie als Black-Box mit Appium über den WebDriver-Hub, oder führen Sie Ihre Espresso-Suite über die TestingBot CLI aus. Beide laufen auf denselben echten Android-Geräten, mit demselben Dashboard, denselben parallelen Slots, Videoaufzeichnung und EU-Datenspeicherort.

  • Echte Android-Geräte und Emulatoren
  • Vergleich der Testhistorie beider Frameworks nebeneinander
  • Kostenlos für Open Source, beide Frameworks
testingbot.com / run both
# Appium
appium:app = 'tb://APP_ID'
hub: https://hub.testingbot.com/wd/hub
# Espresso (@testingbot/cli)
$ testingbot espresso app.apk app-test.apk
--device "Galaxy S24" --real-device
FAQ

Häufig gestellte Fragen

Die Fragen, die sich Teams stellen, bevor sie sich für eines dieser Frameworks entscheiden oder sie kombinieren.

Ist Espresso schneller als Appium?

Ja, auf Android. Espresso läuft In-Process, im selben Prozess wie die App, und vermeidet so die Netzwerk-Roundtrips von Appiums WebDriver-Protokoll und synchronisiert automatisch mit dem UI-Thread. Das macht Espresso schneller und weniger instabil. Der Kompromiss ist, dass Espresso ausschließlich für Android ist und einen instrumentierten Build benötigt, während Appium denselben Test als Black-Box über Android und iOS hinweg ausführt.

Sollte ich Appium oder Espresso für Android verwenden?

Es hängt von Ihren Zielen ab. Für Android-only-UI-Tests, bei denen Ihnen der Quellcode gehört, liefert Espresso die schnellsten und zuverlässigsten Durchläufe. Für plattformübergreifende Abdeckung, Tests in einer Nicht-Kotlin-Sprache oder Apps, die Sie nicht instrumentieren können, passt Appium besser. Viele Android-Teams führen Espresso für Komponenten- und UI-Tests und Appium für plattformübergreifende End-to-End-Flows aus.

Kann Espresso iOS-Apps testen?

Nein. Espresso ist ein Android-only-Framework von Google. Um iOS zu testen, benötigen Sie XCUITest (Apples natives Framework) oder Appium, das iOS im Hintergrund über XCUITest steuert. Appium ist das einzige davon, das denselben Test auf beiden Plattformen ausführt. TestingBot führt alle davon auf echten Geräten aus.

Kann ich dieselben Tests über Android und iOS hinweg wiederverwenden?

Mit Appium, ja. Da Appium das W3C-WebDriver-Protokoll implementiert und die nativen Treiber abstrahiert (UiAutomator2 oder Espresso auf Android, XCUITest auf iOS), kann ein einzelner Test mit geringfügigen Capability-Änderungen auf beide Plattformen abzielen. Espresso kann das nicht; es ist ausschließlich für Android. Wenn die plattformübergreifende Wiederverwendung wichtig ist, ist Appium das zu wählende Framework.

Benötigt Espresso den App-Quellcode?

Ja. Espresso kompiliert zu einem instrumentierten Test-APK, das neben Ihrer App läuft, sodass Sie den App-Quellcode oder zumindest einen debugfähigen, instrumentierten Build benötigen. Appium steuert die installierte App als Black-Box und benötigt keinen Quellcode, weshalb es Drittanbieter- oder bereits veröffentlichte Apps testen kann, die Espresso nicht testen kann.

Kann ich Appium und Espresso auf echten Geräten in der Cloud ausführen?

Ja. TestingBot stellt echte Android-Smartphones und -Tablets sowie Emulatoren in einem EU-Rechenzentrum bereit. Appium-Tests laden Ihr .apk in den TestingBot Storage hoch und laufen gegen den Hub mit gesetztem realDevice; Espresso-Tests laden die App- und Test-APKs über die TestingBot CLI hoch. Beide zeichnen Video und Logs auf, die Sie im Dashboard überprüfen können.

Kann ich Appium und Espresso auf TestingBot ausführen?

Ja, beide laufen auf demselben TestingBot-Raster. Appium lädt Ihre App in den TestingBot Storage hoch und verbindet sich dann mit https://hub.testingbot.com/wd/hub über eine appium:app-Capability von tb://APP_ID. Espresso läuft über die TestingBot CLI: testingbot espresso app.apk app-test.apk --device "Galaxy S24" --real-device. Beide teilen sich dasselbe Dashboard, parallele Slots und denselben EU-Datenspeicherort und sind für Open Source kostenlos.

Sie möchten tiefer eintauchen? Dann besuchen Sie die entsprechenden Seiten zu Appium und Espresso.

Kostenlose Anmeldung

Führen Sie Appium und Espresso auf echten Android-Geräten in der TestingBot-Cloud aus.

Kostenlose Testversion