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.

# Automatisches Ausführen von Appium-Tests in Device Farm
<a name="test-types-appium"></a><a name="test-types-ios-appium-java-testng"></a><a name="test-types-ios-appium-java-junit"></a><a name="test-types-ios-appium-python"></a><a name="test-types-ios-appium-ruby"></a><a name="test-types-ios-appium-node"></a><a name="test-types-android-appium-java-testng"></a><a name="test-types-android-appium-java-junit"></a><a name="test-types-android-appium-python"></a><a name="test-types-android-appium-ruby"></a><a name="test-types-android-appium-node"></a><a name="test-types-web-app-appium-java-testng"></a><a name="test-types-web-app-appium-java-junit"></a><a name="test-types-web-app-appium-python"></a><a name="test-types-web-app-appium-ruby"></a><a name="test-types-web-app-appium-node"></a>

**Anmerkung**  
Diese Seite behandelt die Ausführung von Appium-Tests in der verwalteten **serverseitigen** Ausführungsumgebung von Device Farm. [Informationen zum Ausführen von Appium-Tests in Ihrer lokalen **clientseitigen** Umgebung während einer Fernzugriffssitzung finden Sie unter Clientseitige Appium-Tests.](appium-endpoint.md)

In diesem Abschnitt wird beschrieben, wie Sie Ihre Appium-Tests für die Ausführung in der verwalteten serverseitigen Umgebung von Device Farm konfigurieren, verpacken und hochladen. Appium ist ein Open-Source-Tool zur Automatisierung nativer und mobiler Webanwendungen. Weitere Informationen finden Sie unter [Einführung in Appium](http://appium.io/docs/en/latest/intro) auf der Appium-Website.

Eine Beispiel-App und Links zu funktionierenden Tests finden Sie unter [Device Farm Farm-Beispiel-App für Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) und [Device Farm Farm-Beispiel-App für iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) auf GitHub.

Weitere Informationen zum Testen in Device Farm und zur serverseitigen Funktionsweise finden Sie unter[Test-Frameworks und integrierte Tests in AWS Device Farm](test-types.md).

## Eine Appium-Version auswählen
<a name="w2aac24c15c41"></a>

**Anmerkung**  
 Die Support bestimmter Appium-Versionen, Appium-Treiber oder Programmierung SDKs hängt vom Gerät und dem Testhost ab, die für den Testlauf ausgewählt wurden. 

 Device Farm Farm-Testhosts ist Appium vorinstalliert, um eine schnellere Einrichtung von Tests für einfachere Anwendungsfälle zu ermöglichen. Die Verwendung der Testspezifikationsdatei ermöglicht es Ihnen jedoch, bei Bedarf unterschiedliche Versionen von Appium zu installieren. 

### Szenario 1: Vorkonfigurierte Appium-Version
<a name="w2aac24c15c41b7b1"></a>

 Device Farm ist mit verschiedenen Appium-Serverversionen vorkonfiguriert, die auf dem Testhost basieren. Der Host wird mit Tools geliefert, die die vorkonfigurierte Version mit dem Standardtreiber der Geräteplattform (UiAutomator2 für Android und XCUITest für iOS) aktivieren. 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2
      - devicefarm-cli use appium $APPIUM_VERSION
```

 Eine Liste der unterstützten Software finden Sie im Thema unter. [Unterstützte Software in benutzerdefinierten Testumgebungen](custom-test-environments-hosts-software.md) 

### Szenario 2: Benutzerdefinierte Appium-Version
<a name="w2aac24c15c41b7b3"></a>

 Um eine benutzerdefinierte Version von Appium auszuwählen, verwenden Sie den `npm` Befehl, um sie zu installieren. Das folgende Beispiel zeigt, wie Sie die neueste Version von Appium 2 installieren. 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2
      - npm install -g appium@$APPIUM_VERSION
```

### Szenario 3: Appium auf älteren iOS-Hosts
<a name="w2aac24c15c41b7b5"></a>

 Auf dem [Legacy-iOS-Testhost](custom-test-environments-hosts-ios.md#legacy-ios-host) können Sie bestimmte Appium-Versionen mit auswählen. `avm` Um beispielsweise den `avm` Befehl zu verwenden, um die Appium-Serverversion auf einzustellen`2.1.2`, fügen Sie diese Befehle zu Ihrer YAML-Datei mit Testspezifikationen hinzu. 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2.1.2
      - avm $APPIUM_VERSION
```

## Auswahl einer WebDriverAgent Version für iOS-Tests
<a name="test-types-appium-select-wda"></a>

 Um Appium-Tests auf iOS-Geräten ausführen zu können, WebDriverAgent ist die Verwendung von erforderlich. Diese Anwendung muss signiert sein, um auf iOS-Geräten installiert werden zu können. Device Farm bietet vorsignierte Versionen davon WebDriverAgent , die während der Ausführung benutzerdefinierter Testumgebungen verfügbar sind. 

 Der folgende Codeausschnitt kann verwendet werden, um eine WebDriverAgent Version auf Device Farm in Ihrer Testspezifikationsdatei auszuwählen, die mit Ihrer XCTest UI-Treiberversion kompatibel ist. 

```
phases:
  pre_test:
    commands:
      - |-
        APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1);
        CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}")
        if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then
          echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver";
          DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2)
        else
          LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1)
          echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION";
          DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2)
        fi;
```

 [Weitere Informationen zu finden Sie in der Dokumentation WebDriverAgent von Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) 

# Integration von Appium-Tests mit Device Farm
<a name="test-types-appium-integrate"></a>

Verwenden Sie die folgenden Anweisungen, um Appium-Tests in AWS Device Farm zu integrieren. Weitere Informationen zur Verwendung von Appium-Tests in Device Farm finden Sie unter[Automatisches Ausführen von Appium-Tests in Device FarmIntegration von Appium-Tests mit Device Farm](test-types-appium.md).

## Konfigurieren Sie Ihr Appium-Testpaket
<a name="test-types-appium-prepare"></a>

Anhand der folgenden Anweisungen können Sie Ihr Testpaket konfigurieren.

------
#### [ Java (JUnit) ]

1. Ändern Sie`pom.xml`, um die Paketierung auf eine JAR-Datei festzulegen:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

1. Ändern Sie `pom.xml` so, dass als Zielplattform für den Build Ihrer Tests in einer JAR-Datei `maven-jar-plugin` verwendet wird.

   Das folgende Plugin baut Ihren Testquellcode (alles im `src/test` Verzeichnis) in eine JAR-Datei ein:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

1. Ändern Sie `pom.xml` so, dass die Option `maven-dependency-plugin` verwendet wird, um die Abhängigkeiten als JAR-Dateien zu erzeugen.

   Das folgende Plugin kopiert deine Abhängigkeiten in das `dependency-jars` Verzeichnis: 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

1. Speichern Sie die folgende XML-Assembly-Struktur nach `src/main/assembly/zip.xml`.

   Das folgende XML ist eine Assemblydefinition, die, wenn sie konfiguriert ist, Maven anweist, eine .zip-Datei zu erstellen, die alles enthält, was sich im Stammverzeichnis Ihres Build-Ausgabeverzeichnisses und im Verzeichnis befindet: `dependency-jars` 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

1. Ändern Sie `pom.xml` so, dass `maven-assembly-plugin` die Tests und alle Abhängigkeiten zusammen in einer ZIP-Datei paketiert.

   Das folgende Plug-in verwendet die Assembly-Struktur oben, um jedes Mal, wenn der Befehl **mvn package** ausgeführt wird, eine ZIP-Datei mit dem Namen `zip-with-dependencies` im Build-Ausgabeverzeichnis zu erstellen: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**Anmerkung**  
Wenn Sie eine Fehlermeldung erhalten, dass in Version 1.3 Anmerkungen nicht unterstützt werden, fügen Sie Folgendes in `pom.xml` ein:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Java (TestNG) ]

1. Ändern Sie`pom.xml`, um die Paketierung auf eine JAR-Datei festzulegen:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

1. Ändern Sie `pom.xml` so, dass als Zielplattform für den Build Ihrer Tests in einer JAR-Datei `maven-jar-plugin` verwendet wird.

   Das folgende Plugin baut Ihren Testquellcode (alles im `src/test` Verzeichnis) in eine JAR-Datei ein:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

1. Ändern Sie `pom.xml` so, dass die Option `maven-dependency-plugin` verwendet wird, um die Abhängigkeiten als JAR-Dateien zu erzeugen.

   Das folgende Plugin kopiert deine Abhängigkeiten in das `dependency-jars` Verzeichnis: 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

1. Speichern Sie die folgende XML-Assembly-Struktur nach `src/main/assembly/zip.xml`.

   Das folgende XML ist eine Assemblydefinition, die, wenn sie konfiguriert ist, Maven anweist, eine .zip-Datei zu erstellen, die alles enthält, was sich im Stammverzeichnis Ihres Build-Ausgabeverzeichnisses und im Verzeichnis befindet: `dependency-jars` 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

1. Ändern Sie `pom.xml` so, dass `maven-assembly-plugin` die Tests und alle Abhängigkeiten zusammen in einer ZIP-Datei paketiert.

   Das folgende Plug-in verwendet die Assembly-Struktur oben, um jedes Mal, wenn der Befehl **mvn package** ausgeführt wird, eine ZIP-Datei mit dem Namen `zip-with-dependencies` im Build-Ausgabeverzeichnis zu erstellen: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**Anmerkung**  
Wenn Sie eine Fehlermeldung erhalten, dass in Version 1.3 Anmerkungen nicht unterstützt werden, fügen Sie Folgendes in `pom.xml` ein:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Node.JS ]

Um Ihre Appium Node.js Tests zu packen und auf Device Farm hochzuladen, müssen Sie Folgendes auf Ihrem lokalen Computer installieren:
+ [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm) 

  Verwenden Sie dieses Tool, wenn Sie Ihre Tests entwickeln und Testpakete erstellen, damit keine unnötigen Abhängigkeiten in Ihr Testpaket eingeschlossen werden.
+ Node.js
+ npm-bundle (global installiert)

1. Stellen Sie sicher, dass nvm vorhanden ist.

   ```
   command -v nvm
   ```

   Sie sollten als Ausgabe `nvm` sehen.

   Weitere Informationen finden Sie unter [nvm on](https://github.com/nvm-sh/nvm). GitHub

1. Führen Sie diesen Befehl aus, um Node.js zu installieren:

   ```
   nvm install node
   ```

   Sie können eine bestimmte Version von Node.js angeben:

   ```
   nvm install 11.4.0
   ```

1. Stellen Sie sicher, dass die richtige Version von Node verwendet wird:

   ```
   node -v
   ```

1. Installieren Sie **npm-bundle** global:

   ```
   npm install -g npm-bundle
   ```

------
#### [ Python ]

1. Es wird ausdrücklich empfohlen, das [Python-Tool virtualenv](https://pypi.python.org/pypi/virtualenv) für die Entwicklung und Erstellen von Testpaketen einzurichten und zu verwenden, um zu vermeiden, dass unnötige Abhängigkeiten in Ihr App-Paket aufgenommen werden.

   ```
   $ virtualenv workspace
   $ cd workspace
   $ source bin/activate
   ```
**Tipp**  
Erstellen Sie keine virtuelle Python-Umgebung mit der Option `--system-site-packages`, da in diesem Fall Pakete aus Ihrem globalen Verzeichnis „site-packages“ vererbt werden. Dies kann dazu führen, dass Abhängigkeiten in Ihre virtuelle Umgebung eingeschlossen werden, die von Ihren Tests nicht benötigt werden.
Sie sollten auch sicherstellen, dass Ihre Tests keine Abhängigkeiten von nativen Bibliotheken verwenden, da nicht sicher ist, ob diese nativen Bibliotheken in der Instance vorhanden sind, in der die Tests ausgeführt werden.

1. Installieren Sie **py.test** in Ihrer virtuellen Umgebung.

   ```
   $ pip install pytest
   ```

1. Installieren Sie den Appium Python-Client in Ihrer virtuellen Umgebung.

   ```
   $ pip install Appium-Python-Client
   ```

1. Sofern Sie im benutzerdefinierten Modus keinen anderen Pfad angeben, erwartet Device Farm, dass Ihre Tests in gespeichert werden`tests/`. Sie können `find` verwenden, um alle Dateien in einem Ordner anzuzeigen:

   ```
   $ find tests/
   ```

   Stellen Sie sicher, dass diese Dateien Testsuiten enthalten, die Sie auf Device Farm ausführen möchten

   ```
   tests/
   tests/my-first-tests.py
   tests/my-second-tests/py
   ```

1. Führen Sie diesen Befehl vom Workspace-Ordner in Ihrer virtuellen Umgebung aus, um eine Liste Ihrer Tests anzuzeigen, ohne sie auszuführen.

   ```
   $ py.test --collect-only tests/
   ```

   Vergewissern Sie sich, dass in der Ausgabe die Tests angezeigt werden, die Sie auf Device Farm ausführen möchten.

1. Bereinigen Sie alle zwischengespeicherten Dateien unter Ihrem „tests/“-Ordner:

   ```
   $ find . -name '__pycache__' -type d -exec rm -r {} +
   $ find . -name '*.pyc' -exec rm -f {} +
   $ find . -name '*.pyo' -exec rm -f {} +
   $ find . -name '*~' -exec rm -f {} +
   ```

1. Führen Sie in Ihrem Workspace den folgenden Befehl zum Generieren der requirements.txt-Datei aus:

   ```
   $ pip freeze > requirements.txt
   ```

------
#### [ Ruby ]

Um Ihre Appium Ruby-Tests zu packen und auf Device Farm hochzuladen, müssen Sie Folgendes auf Ihrem lokalen Computer installieren:
+ [Ruby Version Manager (RVM)](https://rvm.io/rvm/install)

  Verwenden Sie dieses Befehlszeilen-Tool, wenn Sie Ihre Tests entwickeln und Testpakete erstellen, um zu vermeiden, dass unnötige Abhängigkeiten in Ihr Testpaket eingeschlossen werden. 
+ Ruby
+ Bundler (Dieses Gem wird in der Regel mit Ruby installiert.)

1. Installieren Sie die erforderlichen Schlüssel, RVM und Ruby. Anweisungen finden Sie unter [Installing RVM](https://rvm.io/rvm/install) auf der RVM-Website.

   Nachdem die Installation abgeschlossen wurde, laden Sie Ihr Terminal erneut, indem Sie sich abmelden und dann erneut wieder anmelden.
**Anmerkung**  
RVM wird als Funktion nur für die bash-Shell geladen.

1. Stellen Sie sicher, dass **rvm** korrekt installiert ist.

   ```
   command -v rvm
   ```

   Sie sollten als Ausgabe `rvm` sehen.

1. Wenn Sie beispielsweise eine bestimmte Version von Ruby installieren möchten*2.5.3*, führen Sie den folgenden Befehl aus:

   ```
   rvm install ruby 2.5.3 --autolibs=0
   ```

   Stellen Sie sicher, dass Sie die angeforderte Version von Ruby verwenden:

   ```
   ruby -v
   ```

1. Konfigurieren Sie den Bundler so, dass er Pakete für Ihre gewünschten Testplattformen kompiliert:

   ```
   bundle config specific_platform true
   ```

1. Aktualisieren Sie Ihre .lock-Datei, um die Plattformen hinzuzufügen, die für die Ausführung von Tests benötigt werden.
   + Wenn Sie Tests für die Ausführung auf Android-Geräten kompilieren, führen Sie diesen Befehl aus, um das Gemfile so zu konfigurieren, dass es Abhängigkeiten für den Android-Testhost verwendet:

     ```
     bundle lock --add-platform x86_64-linux
     ```
   + Wenn Sie Tests für die Ausführung auf iOS-Geräten kompilieren, führen Sie diesen Befehl aus, um das Gemfile so zu konfigurieren, dass es Abhängigkeiten für den iOS-Testhost verwendet:

     ```
     bundle lock --add-platform x86_64-darwin
     ```

1. Das Gem **bundler** ist normalerweise standardmäßig installiert. Wenn dies nicht der Fall ist, installieren Sie es:

   ```
   gem install bundler -v 2.3.26
   ```

------

## Erstellen Sie eine komprimierte Testpaketdatei
<a name="test-types-appium-create-a-zip"></a>

**Warnung**  
In Device Farm ist die Ordnerstruktur der Dateien in Ihrem komprimierten Testpaket wichtig, und einige Archivierungstools ändern die Struktur Ihrer ZIP-Datei implizit. Wir empfehlen, dass Sie die unten angegebenen Befehlszeilenprogramme verwenden, anstatt die in den Dateimanager Ihres lokalen Desktops integrierten Archivierungsprogramme (wie Finder oder Windows Explorer) zu verwenden.

Bündeln Sie nun Ihre Tests für die Device Farm.

------
#### [ Java (JUnit) ]

Erstellen und verpacken Sie Ihre Tests:

```
$ mvn clean package -DskipTests=true
```

Als Ergebnis wird die Datei `zip-with-dependencies.zip` erstellt. Dies ist Ihr Testpaket.

------
#### [ Java (TestNG) ]

Erstellen und verpacken Sie Ihre Tests:

```
$ mvn clean package -DskipTests=true
```

Als Ergebnis wird die Datei `zip-with-dependencies.zip` erstellt. Dies ist Ihr Testpaket.

------
#### [ Node.JS ]

1. Überprüfen Sie Ihr Projekt.

   Stellen Sie sicher, dass Sie sich im Stammverzeichnis Ihres Projekts befinden. Sie sehen `package.json` im Stammverzeichnis.

1. Führen Sie diesen Befehl aus, um Ihre lokalen Abhängigkeiten zu installieren.

   ```
   npm install
   ```

   Dieser Befehl erstellt außerdem den Ordner `node_modules` in Ihrem aktuellen Verzeichnis.
**Anmerkung**  
Zu diesem Zeitpunkt sollten Sie in der Lage sein, Ihre Tests lokal auszuführen.

1. Führen Sie diesen Befehl aus, um aus den Dateien in Ihrem aktuellen Ordner ein Testpaket in Form einer \$1.tgz-Datei zu erstellen. Die Datei wird unter Verwendung der Eigenschaft `name` in Ihrer `package.json`-Datei benannt.

   ```
   npm-bundle
   ```

   Diese Tarball-Datei (.tgz) enthält Ihren gesamten Code und alle Abhängigkeiten.

1. Führen Sie diesen Befehl aus, um den im vorherigen Schritt erstellten Tarball (\$1.tgz-Datei) in einem einzigen ZIP-Archiv zu bündeln:

   ```
   zip -r MyTests.zip *.tgz
   ```

   Dies ist die `MyTests.zip` Datei, die Sie im folgenden Verfahren auf Device Farm hochladen.

------
#### [ Python ]

Python 2  
Generieren Sie mit pip ein Archiv der erforderlichen Python-Pakete (als „Wheelhouse“ bezeichnet):  

```
$ pip wheel --wheel-dir wheelhouse -r requirements.txt
```
Packen Sie Ihr Wheelhouse, Ihre Tests und Ihre Pip-Anforderungen in ein Zip-Archiv für Device Farm:  

```
$ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt
```

Python 3  
Packen Sie Ihre Tests und Pip-Anforderungen in eine ZIP-Datei:  

```
$ zip -r test_bundle.zip tests/ requirements.txt
```

------
#### [ Ruby ]

1. Führen Sie diesen Befehl aus, um eine virtuelle Ruby-Umgebung zu erstellen:

   ```
   # myGemset is the name of your virtual Ruby environment
   rvm gemset create myGemset
   ```

1. Führen Sie diesen Befehl aus, um die Umgebung, die Sie gerade erstellt haben, zu verwenden:

   ```
   rvm gemset use myGemset
   ```

1. Überprüfen Sie den Quellcode.

   Stellen Sie sicher, dass Sie sich im Stammverzeichnis Ihres Projekts befinden. Sie sehen `Gemfile` im Stammverzeichnis.

1. Führen Sie diesen Befehl aus, um Ihre lokalen Abhängigkeiten und alle Gems aus der `Gemfile` zu installieren:

   ```
   bundle install
   ```
**Anmerkung**  
Zu diesem Zeitpunkt sollten Sie in der Lage sein, Ihre Tests lokal auszuführen. Mit diesem Befehl können Sie einen lokalen Test ausführen:  

   ```
   bundle exec $test_command
   ```

1. Verpacken Sie Ihre Gems im Ordner `vendor/cache`.

   ```
   # This will copy all the .gem files needed to run your tests into the vendor/cache directory
   bundle package --all-platforms
   ```

1. Führen Sie den folgenden Befehl aus, um Ihren Quellcode zusammen mit allen Ihren Abhängigkeiten in einem einzigen ZIP-Archiv zu bündeln:

   ```
   zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files)
   ```

   Dies ist die `MyTests.zip` Datei, die Sie im folgenden Verfahren auf Device Farm hochladen.

------

## Laden Sie Ihr Testpaket auf Device Farm hoch
<a name="test-types-appium-upload"></a>

Sie können die Device Farm Farm-Konsole verwenden, um Ihre Tests hochzuladen.

1. Melden Sie sich bei der Device Farm Farm-Konsole unter [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm) an.

1. Wählen Sie im Navigationsbereich Device Farm die Option **Mobile Device Testing** und dann **Projects** aus.

1. Wenn Sie ein neuer Benutzer sind, wählen Sie „**Neues Projekt**“, geben Sie einen Namen für das Projekt ein und wählen Sie dann „**Senden**“.

   Wenn Sie bereits ein Projekt haben, können Sie es auswählen, um Ihre Tests darauf hochzuladen.

1. Öffnen Sie Ihr Projekt und wählen Sie dann **Create run aus**.

1. Geben Sie Ihrem Test unter **Ausführungseinstellungen** einen passenden Namen. Dieser kann eine beliebige Kombination aus Leerzeichen oder Satzzeichen enthalten.

1.   
Für native Android- und iOS-Tests  
Wählen Sie unter **Einstellungen ausführen** die Option **Android-App** aus, wenn Sie eine Android-Anwendung (.apk) testen, oder wählen Sie **iOS-App**, wenn Sie eine iOS-Anwendung (.ipa) testen. Wählen Sie dann unter **App auswählen die Option Eigene App** **hochladen** aus, um das verteilbare Paket Ihrer Anwendung hochzuladen.  
 Die Datei muss entweder eine Android `.apk`- oder eine iOS `.ipa`-Datei sein. iOS-Anwendungen müssen für echte Geräte erstellt werden, nicht für den Simulator.   
Für Tests von mobilen Webanwendungen  
Wählen **Sie unter Einstellungen ausführen** die Option **Web-App** aus.

1. Wählen **Sie unter Test konfigurieren** im Abschnitt **Testframework auswählen** das Appium-Framework aus, mit dem Sie testen, und **laden Sie dann Ihr eigenes Testpaket** hoch.

1. Navigieren Sie zu der ZIP-Datei, die Ihre Tests enthält, und wählen Sie diese aus. Die ZIP-Datei muss dem Format entsprechen, das unter [Konfigurieren Sie Ihr Appium-Testpaket](#test-types-appium-prepare) beschrieben wird.

1. Folgen Sie den Anweisungen, um Geräte auszuwählen und den Testlauf zu starten. Weitere Informationen finden Sie unter [Einen Testlauf in Device Farm erstellen](how-to-create-test-run.md).

**Anmerkung**  
Device Farm ändert Appium-Tests nicht.

## Machen Sie Screenshots Ihrer Tests (optional)
<a name="test-types-appium-screenshots"></a>

Sie können im Rahmen Ihrer Tests Screenshots erstellen.

Device Farm setzt das `DEVICEFARM_SCREENSHOT_PATH`-Attribut auf einen vollqualifizierten Pfad auf dem lokalen Dateisystem. Device Farm erwartet, dass Appium-Screenshots unter diesem Pfad gespeichert werden. Das testspezifische Verzeichnis, in dem die Screenshots gespeichert werden, wird zur Laufzeit definiert. Die Screenshots werden automatisch in Ihre Device Farm-Berichte eingebunden. Sie können die Screenshots in der Device Farm-Konsole im Bereich **Screenshots** anzeigen.

 Weitere Informationen zum Erstellen von Screenshots in Appium-Tests finden Sie unter [Take Screenshot (Screenshot erstellen)](http://appium.io/docs/en/commands/session/screenshot/) in der Appium-API-Dokumentation.