Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Appium-Tests in der AWS Device Farm
Während einer Fernzugriffssitzung können Sie Appium-Tests von Ihrer lokalen Umgebung aus ausführen und dabei über einen verwalteten Appium-Endpunkt auf das Gerät der Sitzung abzielen. Mit einem Appium-Endpunkt können Sie Appium-Code mit schnellem Feedback und schneller Iteration entwickeln, testen und ausführen. Dieser **clientseitige** Testansatz bietet die Flexibilität, von einer beliebigen Appium-Client-Umgebung Ihrer Wahl aus eine Verbindung zu einem Device Farm Farm-Gerät herzustellen.
Als Ergänzung zu clientseitigen Tests unterstützt Device Farm auch das Ausführen von Tests auf der vom Dienst verwalteten Infrastruktur, die als **serverseitige** Ausführung bezeichnet wird. Bei diesem Ansatz können Sie Ihre App und Tests in den Service hochladen und die Tests dann parallel auf mehreren Geräten mithilfe von vom Service verwalteten [Testhosts](custom-test-environments-hosts.md) ausführen. Dieser Ansatz eignet sich gut für Tests auf vielen Geräten unabhängig voneinander sowie für Tests im Kontext einer CI/CD Pipeline.
Weitere Informationen zur serverseitigen Ausführung finden Sie unter[Test-Frameworks und integrierte Tests in AWS Device Farm](test-types.md).
**Topics**
+ [Was ist ein Appium-Endpunkt?](#appium-endpoint-what-is)
+ [Erste Schritte mit Appium-Tests](appium-endpoint-getting-started.md)
+ [Interaktion mit dem Gerät mithilfe von Appium](appium-endpoint-interaction.md)
+ [Überprüfung Ihrer Appium-Serverprotokolle](appium-endpoint-server-logs.md)
+ [Unterstützte Appium-Funktionen und -Befehle](appium-endpoint-supported-caps-and-commands.md)
## Was ist ein Appium-Endpunkt?
[Appium](https://appium.io/) ist ein beliebtes Open-Source-Software-Test-Framework zum Testen nativer, hybrider und mobiler Webanwendungen auf verschiedenen Geräten, einschließlich Mobiltelefonen und Tablets, sowohl für iOS als auch für Android. Es ermöglicht Entwicklern und QA-Technikern (Qualitätssicherung), Skripte zu schreiben, mit denen ein Gerät ferngesteuert, Benutzerinteraktionen simuliert und überprüft werden kann, ob sich die zu testende Anwendung erwartungsgemäß verhält. Appium interagiert mit Apps aus der Perspektive eines Endbenutzers und ermöglicht es Testern, Tests zu entwickeln, die simulieren, wie echte Benutzer die App für ihre Tests verwenden werden.
Appium basiert auf dem Client-Server-Modell, bei dem ein lokaler Client einen (lokalen oder entfernten) Appium-Server anfordert, ein Gerät in seinem Namen zu steuern. Der Appium-Server verwaltet einen Treiber für die Kommunikation mit dem Gerät, z. B. den [UIAutomator2 Treiber](https://github.com/appium/appium-uiautomator2-driver/) für Android oder den [XCUITest Treiber](https://appium.github.io/appium-xcuitest-driver/9.10/) für iOS. Alle Befehle folgen den [ WebDriverW3C-Standards](https://www.w3.org/TR/webdriver2/) für die Steuerung eines Geräts.
Der Appium-Endpunkt von Device Farm macht eine Appium-Server-URL für das Gerät in Ihrer Fernzugriffssitzung verfügbar. Die Appium-Endpunkt-URL ist für dieses Gerät in dieser Sitzung spezifisch und bleibt für die Dauer der Sitzung gültig, sodass Sie ohne zusätzliche Einrichtungszeit auf demselben Gerät iterieren können. Weitere Informationen zum Fernzugriff finden Sie unter. [Fernzugriff in AWS Device Farm](remote-access.md)
# Erste Schritte mit Appium-Tests
Für die meisten Appium-Benutzer erfordert die Verwendung von Device Farm für Appium-Tests nur geringfügige Änderungen an Ihrer vorhandenen Testkonfiguration.
Im Großen und Ganzen besteht die Verwendung von Device Farm für clientseitige Appium-Tests aus drei Schritten:
1. Zunächst müssen Sie [eine Fernzugriffssitzung zum Testen eines Device Farm Farm-Geräts erstellen](how-to-create-session.md). Sie können Ihre Apps in Ihre Fernzugriffsanfrage aufnehmen oder Apps nach dem Start der Sitzung installieren.
1. Sobald die Sitzung läuft, können Sie [die Appium-Endpunkt-URL kopieren](appium-endpoint-interaction.md) und sie entweder über ein eigenständiges Tool (wie [Appium Inspector) oder über Ihren Appium-Testcode](https://github.com/appium/appium-inspector) in Ihrer IDE verwenden. Die URL ist für die Dauer der Fernzugriffssitzung gültig.
1. Und schließlich können Sie nach dem Start Ihres Appium-Tests [Ihre Appium-Serverprotokolle während der Testausführung zusammen mit dem Videostream Ihres Geräts live überprüfen](appium-endpoint-server-logs.md).
# Interaktion mit dem Gerät mithilfe von Appium
Sobald Sie [eine Fernzugriffssitzung erstellt](how-to-create-session.md) haben, steht das Gerät für Appium-Tests zur Verfügung. Während der gesamten Dauer der Fernzugriffssitzung können Sie auf dem Gerät so viele Appium-Sitzungen ausführen, wie Sie möchten, ohne Einschränkungen, welche Clients Sie verwenden. Sie können beispielsweise damit beginnen, einen Test mit Ihrem lokalen Appium-Code von Ihrer IDE aus auszuführen und dann zur Verwendung von Appium Inspector übergehen, um alle auftretenden Probleme zu beheben. Die Sitzung kann bis zu [150 Minuten](limits.md#service-limits) dauern. Wenn jedoch länger als 5 Minuten keine Aktivität stattfindet (entweder über die interaktive Konsole oder über den Appium-Endpunkt), wird die Sitzung unterbrochen.
## Apps zum Testen mit Ihrer Appium-Sitzung verwenden
Device Farm ermöglicht es Ihnen, Ihre App (s) als Teil Ihrer Anfrage zur Erstellung einer Fernzugriffssitzung zu verwenden oder Apps während der Fernzugriffssitzung selbst zu installieren. Diese Apps werden automatisch auf dem zu testenden Gerät installiert und als Standardfunktionen für alle Appium-Sitzungsanfragen bereitgestellt. Wenn Sie eine Fernzugriffssitzung erstellen, haben Sie die Möglichkeit, einen App-ARN zu übergeben, der standardmäßig als `appium:app` Funktion für alle nachfolgenden Appium-Sitzungen verwendet wird, sowie eine Hilfs-App ARNs, die als `appium:otherApps` Funktion verwendet wird.
Wenn Sie beispielsweise eine Fernzugriffssitzung mit einer App `com.aws.devicefarm.sample` als App und `com.aws.devicefarm.other.sample` als einer Ihrer Zusatz-Apps erstellen, verfügt sie bei der Erstellung einer Appium-Sitzung über Funktionen, die den folgenden ähneln:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.other.sample.apk\"]",
...
}
}
}
```
Während Ihrer Sitzung können Sie zusätzliche Apps installieren (entweder innerhalb der Konsole oder mithilfe der [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_InstallToRemoteAccessSession.html)API). Diese überschreiben alle vorhandenen Apps, die zuvor als `appium:app` Funktion verwendet wurden. Wenn diese zuvor verwendeten Apps einen eindeutigen Paketnamen haben, bleiben sie auf dem Gerät und werden als Teil der `appium:otherApps` Funktion verwendet.
Wenn Sie beispielsweise `com.aws.devicefarm.sample` bei der Erstellung Ihrer Fernzugriffssitzung zunächst eine App verwenden, dann aber `com.aws.devicefarm.other.sample` während der Sitzung eine neue App mit dem Namen installieren, verfügen Ihre Appium-Sitzungen über Funktionen, die den folgenden ähneln:
```
{
"value":
{
"sessionId": "abcdef123456-1234-5678-abcd-abcdef123456",
"capabilities":
{
"app": "/tmp/com.aws.devicefarm.other.sample.apk",
"otherApps": "[\"/tmp/com.aws.devicefarm.sample.apk\"]",
...
}
}
}
```
Wenn Sie möchten, können Sie die Funktionen für Ihre App explizit anhand des App-Namens angeben (mit den `appium:bundleId` Funktionen `appium:appPackage` oder für Android bzw. iOS).
Wenn Sie eine Web-App testen, geben Sie die `browserName` Funktion für Ihre Appium-Sitzungserstellungsanfrage an. Der `Chrome` Browser ist auf allen Android-Geräten verfügbar, und der `Safari` Browser ist auf allen iOS-Geräten verfügbar.
Device Farm unterstützt die Übergabe einer Remote-URL oder eines lokalen Dateisystempfads `appium:app` während einer Fernzugriffssitzung nicht. Laden Sie Apps auf Device Farm hoch und nehmen Sie sie stattdessen in die Sitzung auf.
**Anmerkung**
Weitere Informationen zum automatischen Hochladen von Apps als Teil Ihrer Fernzugriffssitzung finden Sie unter [Automatisieren von App-Uploads](api-ref.md#upload-example).
## Wie benutzt man den Appium-Endpunkt
Hier sind die Schritte für den Zugriff auf den Appium-Endpunkt der Sitzung über die Konsole AWS CLI, den und den. AWS SDKs Diese Schritte beinhalten die ersten Schritte mit der Ausführung von Tests unter Verwendung verschiedener Appium-Client-Testframeworks:
------
#### [ Console ]
1. Öffnen Sie die Seite Ihrer Fernzugriffssitzung in Ihrem Webbrowser:
![\[\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint.png)
1. Gehen Sie wie folgt vor, um eine Sitzung mit Appium Inspector auszuführen:
1. Klicken Sie auf die Schaltfläche **Appium-Sitzung einrichten**
1. Folgen Sie den Anweisungen auf der Seite zum Starten einer Sitzung mit Appium Inspector.
1. Gehen Sie wie folgt vor, um einen Appium-Test von Ihrer lokalen IDE aus auszuführen:
1. Klicken Sie auf das Symbol „Kopieren“ neben dem Text **Appium-Endpunkt-URL**
1. Fügen Sie diese URL an der Stelle, an der Sie derzeit Ihre Remote-Adresse oder Ihren Befehlsausführer angeben, in Ihren lokalen Appium-Code ein. Für sprachspezifische Beispiele klicken Sie bitte auf eine der Registerkarten in diesem Beispielfenster für die Sprache Ihrer Wahl.
------
#### [ AWS CLI ]
Stellen Sie zunächst sicher, dass Ihre AWS-CLI-Version vorhanden ist, up-to-date indem Sie [die neueste Version herunterladen und installieren](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Wichtig**
Das Appium-Endpunktfeld ist in älteren Versionen der AWS-CLI nicht verfügbar.
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
$ aws devicefarm get-remote-access-session \
--arn "arn:aws:devicefarm:us-west-2:123456789876:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
{
"remoteAccessSession": {
"arn": "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000",
"name": "Google Pixel 8",
"status": "RUNNING",
"endpoints": {
"remoteDriverEndpoint": "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234...",
...
}
```
Sie können diese URL in Ihrem lokalen Appium-Code überall dort verwenden, wo Sie derzeit Ihre Remote-Adresse oder Ihren Befehlsausführer angeben. Für sprachspezifische Beispiele klicken Sie bitte auf eine der Registerkarten in diesem Beispielfenster für die Sprache Ihrer Wahl.
Ein Beispiel dafür, wie Sie direkt von der Befehlszeile aus mit dem Endpunkt interagieren können, finden Sie mit dem [Befehlszeilentool curl](https://curl.se/), um einen Endpunkt direkt aufzurufen: WebDriver
```
$ curl "https://devicefarm-interactive-global.us-west-2.api.aws/remote-endpoint/ABCD1234.../status"
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
{
"value":
{
"ready": true,
"message": "The server is ready to accept new connections",
"build":
{
"version": "2.5.1"
}
}
}
```
------
#### [ Python ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)API-Aufruf benannt ist:
```
# To get the URL
import sys
import boto3
from botocore.exceptions import ClientError
def get_appium_endpoint() -> str:
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
device_farm_client = boto3.client("devicefarm", region_name="us-west-2")
try:
resp = device_farm_client.get_remote_access_session(arn=session_arn)
except ClientError as exc:
sys.exit(f"Failed to call Device Farm: {exc}")
remote_access_session = resp.get("remoteAccessSession", {})
endpoints = remote_access_session.get("endpoints", {})
endpoint = endpoints.get("remoteDriverEndpoint")
if not endpoint:
sys.exit("Device Farm response did not include endpoints.remoteDriverEndpoint")
return endpoint
# To use the URL
from appium import webdriver
from appium.options.android import UiAutomator2Options
opts = UiAutomator2Options()
driver = webdriver.Remote(get_appium_endpoint(), options=opts)
# ...
driver.quit()
```
------
#### [ Java ]
*Hinweis: Dieses Beispiel verwendet das AWS SDK for Java v2 und ist mit JDK-Versionen 11 und höher kompatibel.*
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionRequest;
import software.amazon.awssdk.services.devicefarm.model.GetRemoteAccessSessionResponse;
public class AppiumEndpointBuilder {
public static String getAppiumEndpoint() throws Exception {
String session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.credentialsProvider(DefaultCredentialsProvider.create())
.build()) {
GetRemoteAccessSessionResponse resp = client.getRemoteAccessSession(
GetRemoteAccessSessionRequest.builder().arn(session_arn).build()
);
String endpoint = resp.remoteAccessSession().endpoints().remoteDriverEndpoint();
if (endpoint == null || endpoint.isEmpty()) {
throw new IllegalStateException("remoteDriverEndpoint missing from response");
}
return endpoint;
}
}
}
// To use the URL
import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URL;
public class ExampleTest {
public static void main(String[] args) throws Exception {
String endpoint = AppiumEndpointBuilder.getAppiumEndpoint();
UiAutomator2Options options = new UiAutomator2Options();
AndroidDriver driver = new AndroidDriver(new URL(endpoint), options);
try {
// ... your test ...
} finally {
driver.quit();
}
}
}
```
------
#### [ JavaScript ]
*Hinweis: Dieses Beispiel verwendet AWS SDK für JavaScript v3 und WebDriverIO v8\$1 mit Node 18\$1.*
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
import { DeviceFarmClient, GetRemoteAccessSessionCommand } from "@aws-sdk/client-device-farm";
export async function getAppiumEndpoint() {
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
const client = new DeviceFarmClient({ region: "us-west-2" });
const resp = await client.send(new GetRemoteAccessSessionCommand({ arn: sessionArn }));
const endpoint = resp?.remoteAccessSession?.endpoints?.remoteDriverEndpoint;
if (!endpoint) throw new Error("remoteDriverEndpoint missing from response");
return endpoint;
}
// To use the URL with WebdriverIO
import { remote } from "webdriverio";
(async () => {
const endpoint = await getAppiumEndpoint();
const u = new URL(endpoint);
const driver = await remote({
protocol: u.protocol.replace(":", ""),
hostname: u.hostname,
port: u.port ? Number(u.port) : (u.protocol === "https:" ? 443 : 80),
path: u.pathname + u.search,
capabilities: {
platformName: "Android",
"appium:automationName": "UiAutomator2",
// ...other caps...
},
});
try {
// ... your test ...
} finally {
await driver.deleteSession();
}
})();
```
------
#### [ C\$1 ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
// To get the URL
using System;
using System.Threading.Tasks;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
public static class AppiumEndpointBuilder
{
public static async Task GetAppiumEndpointAsync()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000";
var config = new AmazonDeviceFarmConfig
{
RegionEndpoint = RegionEndpoint.USWest2
};
using var client = new AmazonDeviceFarmClient(config);
var resp = await client.GetRemoteAccessSessionAsync(new GetRemoteAccessSessionRequest { Arn = sessionArn });
var endpoint = resp?.RemoteAccessSession?.Endpoints?.RemoteDriverEndpoint;
if (string.IsNullOrWhiteSpace(endpoint))
throw new InvalidOperationException("RemoteDriverEndpoint missing from response");
return endpoint;
}
}
// To use the URL
using OpenQA.Selenium.Appium;
using OpenQA.Selenium.Appium.Android;
class Example
{
static async Task Main()
{
var endpoint = await AppiumEndpointBuilder.GetAppiumEndpointAsync();
var options = new AppiumOptions();
options.PlatformName = "Android";
options.AutomationName = "UiAutomator2";
using var driver = new AndroidDriver(new Uri(endpoint), options);
try
{
// ... your test ...
}
finally
{
driver.Quit();
}
}
}
```
------
#### [ Ruby ]
Sobald Ihre Sitzung läuft, ist die Appium-Endpunkt-URL über ein Feld verfügbar, das `remoteDriverEndpoint` in der Antwort auf einen API-Aufruf benannt ist: [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRemoteAccessSession.html)
```
# To get the URL
require 'aws-sdk-devicefarm'
def get_appium_endpoint
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:abcdef123456-1234-5678-abcd-abcdef123456/abcdef123456-1234-5678-abcd-abcdef123456/00000"
client = Aws::DeviceFarm::Client.new(region: 'us-west-2')
resp = client.get_remote_access_session(arn: session_arn)
endpoint = resp.remote_access_session.endpoints.remote_driver_endpoint
raise "remote_driver_endpoint missing from response" if endpoint.nil? || endpoint.empty?
endpoint
end
# To use the URL
require 'appium_lib_core'
endpoint = get_appium_endpoint
opts = {
server_url: endpoint,
capabilities: {
'platformName' => 'Android',
'appium:automationName' => 'UiAutomator2'
}
}
driver = Appium::Core.for(opts).start_driver
begin
# ... your test ...
ensure
driver.quit
end
```
------
# Überprüfung Ihrer Appium-Serverprotokolle
Sobald Sie [eine Appium-Sitzung gestartet](appium-endpoint-interaction.md) haben, können Sie die Appium-Serverprotokolle live in der Device Farm Farm-Konsole anzeigen oder sie nach dem Ende der Fernzugriffssitzung herunterladen. Hier sind die Anweisungen dazu:
------
#### [ Console ]
1. Öffnen Sie in der Device Farm Farm-Konsole die Fernzugriffssitzung für Ihr Gerät.
1. Starten Sie eine Appium-Endpunktsitzung mit dem Gerät von Ihrer lokalen IDE oder Appium Inspector aus
1. Anschließend wird das Appium-Serverprotokoll neben dem Gerät auf der Seite für die Fernzugriffssitzung angezeigt. Die „Sitzungsinformationen“ finden Sie unten auf der Seite unter dem Gerät:
![\[\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/aws-device-farm-appium-endpoint-logs.gif)
------
#### [ AWS CLI ]
*Hinweis: In diesem Beispiel wird das [Befehlszeilentool](https://curl.se/) verwendet`curl`, um das Protokoll von Device Farm abzurufen.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um das Appium-Serverprotokoll herunterzuladen.
```
$ aws devicefarm list-artifacts \
--type FILE \
--arn arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000
```
Dadurch werden während der Sitzung Ausgaben wie die folgende angezeigt:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "AppiumServerLogOutput",
"type": "APPIUM_SERVER_LOG_OUTPUT",
"extension": "",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
Und das Folgende, nachdem die Sitzung abgeschlossen ist:
```
{
"artifacts": [
{
"arn": "arn:aws:devicefarm:us-west-2:111122223333:artifact:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000",
"name": "Appium Server Output",
"type": "APPIUM_SERVER_OUTPUT",
"extension": "log",
"url": "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
}
]
}
```
```
$ curl "https://prod-us-west-2-results.s3.dualstack.us-west-2.amazonaws.com/111122223333/12345678..."
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1',
info Appium allowInsecure:
info Appium [ 'execute_driver_script',
info Appium 'session_discovery',
info Appium 'perf_record',
info Appium 'adb_shell',
info Appium 'chromedriver_autodownload',
info Appium 'get_server_logs' ],
info Appium keepAliveTimeout: 0,
info Appium logNoColors: true,
info Appium logTimestamp: true,
info Appium longStacktrace: true,
info Appium sessionOverride: true,
info Appium strictCaps: true,
info Appium useDrivers: [ 'uiautomator' ] }
```
------
#### [ Python ]
*Hinweis: In diesem Beispiel werden das `requests` Drittanbieterpaket zum Herunterladen des Protokolls sowie das AWS SDK für Python verwendet`boto3`.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um die URL des Appium-Serverprotokolls abzurufen und sie dann herunterzuladen.
```
import pathlib
import requests
import boto3
def download_appium_log():
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
client = boto3.client("devicefarm", region_name="us-west-2")
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = None
while True:
kwargs = {"arn": session_arn, "type": "FILE"}
if token:
kwargs["nextToken"] = token
resp = client.list_artifacts(**kwargs)
artifacts.extend(resp.get("artifacts", []))
token = resp.get("nextToken")
if not token:
break
if not artifacts:
raise RuntimeError("No artifacts found in this session")
# Filter strictly to Appium server logs
allowed = {"APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"}
filtered = [a for a in artifacts if a.get("type") in allowed]
if not filtered:
raise RuntimeError("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)")
# Prefer the final 'OUTPUT' log, else the live 'LOG_OUTPUT'
chosen = (next((a for a in filtered if a.get("type") == "APPIUM_SERVER_OUTPUT"), None)
or next((a for a in filtered if a.get("type") == "APPIUM_SERVER_LOG_OUTPUT"), None))
url = chosen["url"]
ext = chosen.get("extension") or "log"
out = pathlib.Path(f"./appium_server_log.{ext}")
# 2) Download the artifact
with requests.get(url, stream=True) as r:
r.raise_for_status()
with open(out, "wb") as fh:
for chunk in r.iter_content(chunk_size=1024 * 1024):
if chunk:
fh.write(chunk)
print(f"Saved Appium server log to: {out.resolve()}")
download_appium_log()
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ Java ]
*Hinweis: Dieses Beispiel verwendet das AWS SDK for Java v2 und `HttpClient` zum Herunterladen des Protokolls und ist mit JDK-Versionen 11 und höher kompatibel.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um die URL des Appium-Serverprotokolls abzurufen und sie dann herunterzuladen.
```
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.devicefarm.DeviceFarmClient;
import software.amazon.awssdk.services.devicefarm.model.Artifact;
import software.amazon.awssdk.services.devicefarm.model.ArtifactCategory;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsRequest;
import software.amazon.awssdk.services.devicefarm.model.ListArtifactsResponse;
public class AppiumLogDownloader {
public static void main(String[] args) throws Exception {
String sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
try (DeviceFarmClient client = DeviceFarmClient.builder()
.region(Region.US_WEST_2)
.build()) {
// 1) List artifacts for the session (FILE artifacts) with pagination
List all = new ArrayList<>();
String token = null;
do {
ListArtifactsRequest.Builder b = ListArtifactsRequest.builder()
.arn(sessionArn)
.type(ArtifactCategory.FILE);
if (token != null) b.nextToken(token);
ListArtifactsResponse page = client.listArtifacts(b.build());
all.addAll(page.artifacts());
token = page.nextToken();
} while (token != null && !token.isBlank());
// Filter strictly to Appium logs
List filtered = all.stream()
.filter(a -> {
String t = a.typeAsString();
return "APPIUM_SERVER_OUTPUT".equals(t) || "APPIUM_SERVER_LOG_OUTPUT".equals(t);
})
.toList();
if (filtered.isEmpty()) {
throw new RuntimeException("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
Artifact chosen = filtered.stream()
.filter(a -> "APPIUM_SERVER_OUTPUT".equals(a.typeAsString()))
.findFirst()
.orElseGet(() -> filtered.stream()
.filter(a -> "APPIUM_SERVER_LOG_OUTPUT".equals(a.typeAsString()))
.findFirst()
.get());
String url = chosen.url();
String ext = (chosen.extension() == null || chosen.extension().isBlank()) ? "log" : chosen.extension();
Path out = Path.of("appium_server_log." + ext);
// 2) Download the artifact with HttpClient
HttpClient http = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(10))
.build();
HttpRequest get = HttpRequest.newBuilder(URI.create(url))
.timeout(Duration.ofMinutes(5))
.GET()
.build();
HttpResponse resp = http.send(get, HttpResponse.BodyHandlers.ofFile(out));
if (resp.statusCode() / 100 != 2) {
throw new IOException("Failed to download log, HTTP " + resp.statusCode());
}
System.out.println("Saved Appium server log to: " + out.toAbsolutePath());
}
}
}
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ JavaScript ]
*Hinweis: In diesem Beispiel wird AWS SDK für JavaScript (v3) und Node 18\$1 verwendet`fetch`, um das Protokoll herunterzuladen.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um die URL des Appium-Serverprotokolls abzurufen und sie dann herunterzuladen.
```
import { DeviceFarmClient, ListArtifactsCommand } from "@aws-sdk/client-device-farm";
import { createWriteStream } from "fs";
import { pipeline } from "stream";
import { promisify } from "util";
const pipe = promisify(pipeline);
const client = new DeviceFarmClient({ region: "us-west-2" });
const sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
// 1) List artifacts for the session (FILE artifacts), handling pagination
const artifacts = [];
let nextToken;
do {
const page = await client.send(new ListArtifactsCommand({
arn: sessionArn,
type: "FILE",
nextToken
}));
artifacts.push(...(page.artifacts ?? []));
nextToken = page.nextToken;
} while (nextToken);
if (!artifacts.length) throw new Error("No artifacts found");
// Strict filter to Appium logs
const filtered = (artifacts ?? []).filter(a =>
a.type === "APPIUM_SERVER_OUTPUT" || a.type === "APPIUM_SERVER_LOG_OUTPUT"
);
if (!filtered.length) {
throw new Error("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
}
// Prefer OUTPUT; else LOG_OUTPUT
const chosen =
filtered.find(a => a.type === "APPIUM_SERVER_OUTPUT") ??
filtered.find(a => a.type === "APPIUM_SERVER_LOG_OUTPUT");
const url = chosen.url;
const ext = chosen.extension || "log";
const outPath = `./appium_server_log.${ext}`;
// 2) Download the artifact
const resp = await fetch(url);
if (!resp.ok) {
throw new Error(`Failed to download log: ${resp.status} ${await resp.text().catch(()=>"")}`);
}
await pipe(resp.body, createWriteStream(outPath));
console.log("Saved Appium server log to:", outPath);
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
#### [ C\$1 ]
*Hinweis: In diesem Beispiel wird das AWS SDK for .NET und `HttpClient` zum Herunterladen des Protokolls verwendet.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um die URL des Appium-Serverprotokolls abzurufen und sie dann herunterzuladen.
```
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using System.Linq;
using Amazon;
using Amazon.DeviceFarm;
using Amazon.DeviceFarm.Model;
class AppiumLogDownloader
{
static async Task Main()
{
var sessionArn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000";
using var client = new AmazonDeviceFarmClient(RegionEndpoint.USWest2);
// 1) List artifacts for the session (FILE artifacts), handling pagination
var all = new List();
string? token = null;
do
{
var page = await client.ListArtifactsAsync(new ListArtifactsRequest
{
Arn = sessionArn,
Type = ArtifactCategory.FILE,
NextToken = token
});
if (page.Artifacts != null) all.AddRange(page.Artifacts);
token = page.NextToken;
} while (!string.IsNullOrEmpty(token));
if (all.Count == 0)
throw new Exception("No artifacts found");
// Strict filter to Appium logs
var filtered = all.Where(a =>
a.Type == "APPIUM_SERVER_OUTPUT" || a.Type == "APPIUM_SERVER_LOG_OUTPUT").ToList();
if (filtered.Count == 0)
throw new Exception("No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT).");
// Prefer OUTPUT; else LOG_OUTPUT
var chosen = filtered.FirstOrDefault(a => a.Type == "APPIUM_SERVER_OUTPUT")
?? filtered.First(a => a.Type == "APPIUM_SERVER_LOG_OUTPUT");
var url = chosen.Url;
var ext = string.IsNullOrWhiteSpace(chosen.Extension) ? "log" : chosen.Extension;
var outPath = $"./appium_server_log.{ext}";
// 2) Download the artifact
using var http = new HttpClient();
using var resp = await http.GetAsync(url, HttpCompletionOption.ResponseHeadersRead);
resp.EnsureSuccessStatusCode();
await using (var fs = File.Create(outPath))
{
await resp.Content.CopyToAsync(fs);
}
Console.WriteLine($"Saved Appium server log to: {Path.GetFullPath(outPath)}");
}
}
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', ..., useDrivers: [ 'uiautomator' ] }
```
------
#### [ Ruby ]
*Hinweis: In diesem Beispiel wird das AWS SDK for Ruby und `Net::HTTP` zum Herunterladen des Protokolls verwendet.*
Während oder nach der Sitzung können Sie die [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)API von Device Farm verwenden, um die URL des Appium-Serverprotokolls abzurufen und sie dann herunterzuladen.
```
require "aws-sdk-devicefarm"
require "net/http"
require "uri"
client = Aws::DeviceFarm::Client.new(region: "us-west-2")
session_arn = "arn:aws:devicefarm:us-west-2:111122223333:session:12345678-1111-2222-333-456789abcdef/12345678-1111-2222-333-456789abcdef/00000"
# 1) List artifacts for the session (FILE artifacts), handling pagination
artifacts = []
token = nil
loop do
page = client.list_artifacts(arn: session_arn, type: "FILE", next_token: token)
artifacts.concat(page.artifacts || [])
token = page.next_token
break if token.nil? || token.empty?
end
raise "No artifacts found" if artifacts.empty?
# Strict filter to Appium logs
filtered = (artifacts || []).select { |a| ["APPIUM_SERVER_OUTPUT", "APPIUM_SERVER_LOG_OUTPUT"].include?(a.type) }
raise "No Appium server log artifacts found (expected APPIUM_SERVER_OUTPUT or APPIUM_SERVER_LOG_OUTPUT)." if filtered.empty?
# Prefer OUTPUT; else LOG_OUTPUT
chosen = filtered.find { |a| a.type == "APPIUM_SERVER_OUTPUT" } ||
filtered.find { |a| a.type == "APPIUM_SERVER_LOG_OUTPUT" }
url = chosen.url
ext = (chosen.extension && !chosen.extension.empty?) ? chosen.extension : "log"
out_path = "./appium_server_log.#{ext}"
# 2) Download the artifact
uri = URI.parse(url)
Net::HTTP.start(uri.host, uri.port, use_ssl: (uri.scheme == "https")) do |http|
req = Net::HTTP::Get.new(uri)
http.request(req) do |resp|
raise "Failed GET: #{resp.code} #{resp.body}" unless resp.code.to_i / 100 == 2
File.open(out_path, "wb") { |f| resp.read_body { |chunk| f.write(chunk) } }
end
end
puts "Saved Appium server log to: #{File.expand_path(out_path)}"
```
Dadurch werden Ausgaben wie die folgende angezeigt:
```
info Appium Welcome to Appium v2.5.4
info Appium Non-default server args:
info Appium { address: '127.0.0.1', allowInsecure: [ 'execute_driver_script', ... ], useDrivers: [ 'uiautomator' ] }
```
------
# Unterstützte Appium-Funktionen und -Befehle
Der Appium-Endpunkt von Device Farm unterstützt die meisten Befehle und gewünschten Funktionen, die Sie auf lokalen Geräten verwenden, mit wenigen Ausnahmen. Die folgenden Listen zeigen, welche Funktionen und Befehle derzeit nicht unterstützt werden. Wenn Ihre Tests aufgrund eingeschränkter Funktionen nicht wie erwartet ausgeführt werden können, wenden Sie sich bitte an einen Support-Fall, um weitere Informationen zu erhalten.
## Unterstützte Funktionen
Wenn Sie eine Appium-Sitzung auf Device Farm erstellen, empfehlen wir, über einen bestimmten Funktionsumfang zu verfügen, der alle für Ihr lokales Gerät spezifischen Funktionen ausschließt. In Device Farm schlägt die Sitzungserstellung möglicherweise fehl, wenn bestimmte nicht unterstützte Funktionen eingestellt sind. Dazu gehören gerätespezifische Funktionen wie und. `udid` `platformVersion` Darüber hinaus werden bestimmte Funktionen, die sich ChromeDriver auf Android und WebDriverAgent iOS beziehen, nicht unterstützt, ebenso wie Funktionen, die nur auf Emulatoren und Simulatoren unterstützt werden.
## Unterstützte Befehle
Die meisten Appium-Befehle, die auf echten Android- und iOS-Geräten ordnungsgemäß ausgeführt werden, werden wie erwartet auf Device Farm ausgeführt, mit den folgenden Ausnahmen:
### Appium-Gerätebefehle () `/appium/device`
+ `install_app`
+ `finger_print`
+ `send_sms`
+ `gsm_call`
+ `gsm_signal`
+ `gsm_voice`
+ `power_ac`
+ `power_capacity`
+ `network_speed`
+ `shake`
### Appium führt Methoden und Skripte aus () `/execute`
+ `installApp`
+ `execEmuConsoleCommand`
+ `fingerprint`
+ `gsmCall`
+ `gsmSignal`
+ `sendSms`
+ `gsmVoice`
+ `powerAC`
+ `powerCapacity`
+ `networkSpeed`
+ `sensorSet`
+ `injectEmulatorCameraImage`
+ `isGpsEnabled`
+ `shake`
+ `clearApp`
+ `clearKeychains`
+ `configureLocalization`
+ `enrollBiometric`
+ `getPasteboard`
+ `installXCTestBundle`
+ `listXCTestBundles`
+ `listXCTestsInTestBundle`
+ `runXCTest`
+ `sendBiometricMatch`
+ `setPasteboard`
+ `setPermission`
+ `startAudioRecording`
+ `startLogsBroadcast`
+ `startRecordingScreen`
+ `startScreenStreaming`
+ `startXCTestScreenRecording`
+ `stopAudioRecording`
+ `stopLogsBroadcast`
+ `stopRecordingScreen`
+ `stopScreenStreaming`
+ `stopXCTestScreenRecording`
+ `updateSafariPreferences`