Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exécuter automatiquement des tests Appium dans 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>

**Note**  
Cette page décrit l'exécution de tests Appium dans l'environnement d'exécution géré **côté serveur** de Device Farm. [Pour exécuter des tests Appium depuis votre environnement local **côté client** lors d'une session d'accès à distance, voir Tests Appium côté client.](appium-endpoint.md)

Cette section décrit comment configurer, empaqueter et télécharger vos tests Appium pour les exécuter dans l'environnement géré côté serveur de Device Farm. Appium est un outil open source permettant d'automatiser les applications Web natives et mobiles. Pour plus d'informations, consultez la page de [présentation d'Appium](http://appium.io/docs/en/latest/intro) sur le site web Appium.

Pour un exemple d'application et des liens vers des tests fonctionnels, voir [Device Farm Sample App pour Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) et [Device Farm Sample App pour iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) sur GitHub.

Pour plus d'informations sur les tests dans Device Farm et sur le fonctionnement côté serveur, consultez. [Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md)

## Sélection d'une version d'Appium
<a name="w2aac24c15c41"></a>

**Note**  
 Support pour des versions spécifiques d'Appium, des pilotes Appium ou de la programmation SDKs dépend du périphérique et de l'hôte de test sélectionnés pour le test. 

 Les hôtes de test Device Farm sont préinstallés avec Appium afin de permettre une configuration plus rapide des tests pour des cas d'utilisation plus simples. Cependant, l'utilisation du fichier de spécifications de test vous permet d'installer différentes versions d'Appium si nécessaire. 

### Scénario 1 : version préconfigurée d'Appium
<a name="w2aac24c15c41b7b1"></a>

 Device Farm est préconfiguré avec différentes versions du serveur Appium en fonction de l'hôte de test. L'hôte est fourni avec des outils qui activent la version préconfigurée avec le pilote par défaut de la plate-forme de l'appareil (UiAutomator2 pour Android et pour XCUITest iOS). 

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

 Pour consulter la liste des logiciels pris en charge, consultez la rubrique sur[Logiciels pris en charge dans des environnements de test personnalisés](custom-test-environments-hosts-software.md). 

### Scénario 2 : version personnalisée d'Appium
<a name="w2aac24c15c41b7b3"></a>

 Pour sélectionner une version personnalisée d'Appium, utilisez la `npm` commande pour l'installer. L'exemple suivant montre comment installer la dernière version d'Appium 2. 

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

### Scénario 3 : Appium sur les anciens hôtes iOS
<a name="w2aac24c15c41b7b5"></a>

 Sur le[Ancien hôte de test iOS](custom-test-environments-hosts-ios.md#legacy-ios-host), vous pouvez choisir des versions spécifiques d'Appium avec. `avm` Par exemple, pour utiliser la `avm` commande permettant de définir la version du serveur Appium sur`2.1.2`, ajoutez ces commandes à votre fichier YAML de spécifications de test. 

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

## Sélection d'une WebDriverAgent version pour les tests iOS
<a name="test-types-appium-select-wda"></a>

 Pour exécuter des tests Appium sur des appareils iOS, l'utilisation de WebDriverAgent est requise. Cette application doit être signée pour être installée sur les appareils iOS. Device Farm fournit des versions pré-signées WebDriverAgent qui sont disponibles lors des exécutions d'environnements de test personnalisés. 

 L'extrait de code suivant peut être utilisé pour sélectionner une WebDriverAgent version de Device Farm dans votre fichier de spécifications de test compatible avec la version de votre pilote d' XCTestinterface utilisateur. 

```
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;
```

 [Pour plus d'informations à ce sujet WebDriverAgent, consultez la documentation d'Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) 

# Intégrer les tests Appium à Device Farm
<a name="test-types-appium-integrate"></a>

Suivez les instructions suivantes pour intégrer les tests Appium à AWS Device Farm. Pour plus d'informations sur l'utilisation des tests Appium dans Device Farm, consultez. [Exécuter automatiquement des tests Appium dans Device FarmIntégrer les tests Appium à Device Farm](test-types-appium.md)

## Configurez votre package de test Appium
<a name="test-types-appium-prepare"></a>

Utilisez les instructions suivantes pour configurer votre package de test.

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

1. Modifiez `pom.xml` pour définir l'empaquetage dans un fichier JAR :

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

1. Modifiez `pom.xml` pour utiliser `maven-jar-plugin` afin de créer vos tests dans un fichier JAR.

   Le plugin suivant crée votre code source de test (tout ce qui se trouve dans le `src/test` répertoire) dans un fichier JAR :

   ```
   <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. Modifiez `pom.xml` pour utiliser `maven-dependency-plugin` afin de créer des dépendances en tant que fichiers JAR.

   Le plugin suivant copie vos dépendances dans le `dependency-jars` répertoire : 

   ```
   <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. Enregistrez l'assemblage XML suivant dans `src/main/assembly/zip.xml`.

   Le code XML suivant est une définition d'assemblage qui, une fois configurée, indique à Maven de créer un fichier .zip contenant tout ce qui se trouve à la racine du répertoire de sortie de votre build et du répertoire : `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. Modifiez le fichier `pom.xml` pour utiliser `maven-assembly-plugin` afin de compresser tous les tests et les dépendances en un seul fichier .zip.

   Le plug-in suivant utilise l'assemblage précédant pour créer un fichier .zip nommé `zip-with-dependencies` dans le répertoire de sortie de build à chaque fois que la commande **mvn package** est exécutée : 

   ```
   <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>
   ```

**Note**  
Si un message d'erreur indique que l'annotation n'est pas prise en charge dans la version 1.3, ajoutez les éléments suivants au fichier `pom.xml` :  

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

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

1. Modifiez `pom.xml` pour définir l'empaquetage dans un fichier JAR :

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

1. Modifiez `pom.xml` pour utiliser `maven-jar-plugin` afin de créer vos tests dans un fichier JAR.

   Le plugin suivant crée votre code source de test (tout ce qui se trouve dans le `src/test` répertoire) dans un fichier JAR :

   ```
   <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. Modifiez `pom.xml` pour utiliser `maven-dependency-plugin` afin de créer des dépendances en tant que fichiers JAR.

   Le plugin suivant copie vos dépendances dans le `dependency-jars` répertoire : 

   ```
   <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. Enregistrez l'assemblage XML suivant dans `src/main/assembly/zip.xml`.

   Le code XML suivant est une définition d'assemblage qui, une fois configurée, indique à Maven de créer un fichier .zip contenant tout ce qui se trouve à la racine du répertoire de sortie de votre build et du répertoire : `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. Modifiez le fichier `pom.xml` pour utiliser `maven-assembly-plugin` afin de compresser tous les tests et les dépendances en un seul fichier .zip.

   Le plug-in suivant utilise l'assemblage précédant pour créer un fichier .zip nommé `zip-with-dependencies` dans le répertoire de sortie de build à chaque fois que la commande **mvn package** est exécutée : 

   ```
   <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>
   ```

**Note**  
Si un message d'erreur indique que l'annotation n'est pas prise en charge dans la version 1.3, ajoutez les éléments suivants au fichier `pom.xml` :  

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

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

Pour empaqueter vos tests Appium Node.js et les télécharger sur Device Farm, vous devez installer les éléments suivants sur votre machine locale :
+ [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm) 

  Utilisez cet outil pour développer et créer vos packages de test afin qu'aucune dépendance inutile n'y soit incluse.
+ Node.js
+ npm-bundle (installé globalement)

1. Vérifiez que nvm est présent

   ```
   command -v nvm
   ```

   Vous devez voir `nvm` en tant que sortie.

   Pour plus d'informations, consultez [nvm](https://github.com/nvm-sh/nvm) on GitHub.

1. Pour installer Node.js, exécutez la commande suivante :

   ```
   nvm install node
   ```

   Vous pouvez spécifier une version particulière de Node.js :

   ```
   nvm install 11.4.0
   ```

1. Vérifiez que la version correcte de Node est en cours d'utilisation :

   ```
   node -v
   ```

1. Installer **npm-bundle** globalement :

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

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

1. Nous vous recommandons vivement de configurer [virtualenv Python](https://pypi.python.org/pypi/virtualenv) pour le développement et la création d'un package de tests afin qu'aucune dépendance inutile ne soit incluse dans votre package d'application.

   ```
   $ virtualenv workspace
   $ cd workspace
   $ source bin/activate
   ```
**Astuce**  
Ne créez pas d'environnement virtualenv Python avec l'option `--system-site-packages`, car il hérite des packages de votre répertoire site-packages global. Cela peut entraîner l'inclusion dans votre environnement virtuel de dépendances qui ne sont pas requises par vos tests.
Vous devez également vérifier que vos tests n'utilisent pas de dépendances aux bibliothèques natives. En effet, il est possible que ces bibliothèques natives ne soient pas présentes sur l'instance sur laquelle ces tests sont exécutés.

1. Installez **py.test** dans votre environnement virtuel.

   ```
   $ pip install pytest
   ```

1. Installez le client Appium Python dans votre environnement virtuel.

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

1. À moins que vous ne spécifiiez un chemin différent en mode personnalisé, Device Farm s'attend à ce que vos tests y soient stockés`tests/`. Vous pouvez utiliser `find` pour afficher tous les fichiers dans un dossier :

   ```
   $ find tests/
   ```

   Vérifiez que ces fichiers contiennent des suites de test que vous souhaitez exécuter sur Device Farm

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

1. Exécutez cette commande à partir du dossier workspace de votre environnement virtuel pour afficher une liste de vos tests sans les exécuter.

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

   Vérifiez que le résultat indique les tests que vous souhaitez exécuter sur Device Farm.

1. Nettoyez tous les fichiers mis en cache sous votre dossier tests/ :

   ```
   $ 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. Exécutez la commande suivante dans votre espace de travail pour générer le fichier requirements.txt :

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

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

Pour empaqueter vos tests Appium Ruby et les télécharger sur Device Farm, vous devez installer les éléments suivants sur votre machine locale :
+ [Ruby Version Manager (RVM)](https://rvm.io/rvm/install)

  Utilisez cet outil de ligne de commande pour développer et créer vos packages de test afin qu'aucune dépendance inutile n'y soit incluse. 
+ Ruby
+ Bundler (Cette gem est généralement installée avec Ruby.)

1. Installez les clés nécessaires, RVM et Ruby. Pour plus d'informations, consultez la [section relative à l'installation de RVM](https://rvm.io/rvm/install) sur le site Web RVM.

   Une fois l'installation terminée, rechargez votre terminal. Pour cela, déconnectez-vous puis reconnectez-vous.
**Note**  
RVM est chargé en tant que fonction pour le shell bash uniquement.

1. Vérifiez que **rvm** est installé correctement.

   ```
   command -v rvm
   ```

   Vous devez voir `rvm` en tant que sortie.

1. Si vous souhaitez installer une version spécifique de Ruby, par exemple*2.5.3*, exécutez la commande suivante :

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

   Vérifiez que vous êtes sur la version demandée de Ruby :

   ```
   ruby -v
   ```

1. Configurez le bundler pour compiler les packages pour les plateformes de test souhaitées :

   ```
   bundle config specific_platform true
   ```

1. Mettez à jour votre fichier .lock pour ajouter les plateformes nécessaires à l'exécution des tests.
   + Si vous compilez des tests à exécuter sur des appareils Android, exécutez cette commande pour configurer le Gemfile afin qu'il utilise les dépendances de l'hôte de test Android :

     ```
     bundle lock --add-platform x86_64-linux
     ```
   + Si vous compilez des tests à exécuter sur des appareils iOS, exécutez cette commande pour configurer le Gemfile afin qu'il utilise les dépendances de l'hôte de test iOS :

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

1. La gem **bundler** est généralement installée par défaut. Si ce n'est pas le cas, installez-la :

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

------

## Création d'un fichier de package de test compressé
<a name="test-types-appium-create-a-zip"></a>

**Avertissement**  
Dans Device Farm, la structure des dossiers des fichiers de votre package de test compressé est importante, et certains outils d'archivage modifieront implicitement la structure de votre fichier ZIP. Nous vous recommandons de suivre les utilitaires de ligne de commande spécifiés ci-dessous plutôt que d'utiliser les utilitaires d'archivage intégrés au gestionnaire de fichiers de votre bureau local (tels que le Finder ou l'Explorateur Windows).

Maintenant, groupez vos tests pour la batterie de périphériques.

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

Construisez et empaquetez vos tests :

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

Le fichier `zip-with-dependencies.zip` sera créé en conséquence. Ceci est votre package de tests.

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

Construisez et empaquetez vos tests :

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

Le fichier `zip-with-dependencies.zip` sera créé en conséquence. Ceci est votre package de tests.

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

1. Vérifiez votre projet.

   Assurez-vous d'être dans le répertoire racine de votre projet. Vous pouvez voir `package.json` dans le répertoire racine.

1. Pour installer vos dépendances locales, exécutez la commande suivante.

   ```
   npm install
   ```

   Cette commande crée également un dossier `node_modules` au sein de votre répertoire actuel.
**Note**  
À ce stade, vous devriez être en mesure d'exécuter vos tests en local.

1. Exécutez cette commande pour regrouper les fichiers de votre dossier actif dans un package \$1.tgz. Le fichier créé est nommé en fonction de la propriété `name` indiquée dans votre fichier `package.json`.

   ```
   npm-bundle
   ```

   Ce fichier tarball (.tgz) contient votre code et toutes les dépendances.

1. Exécutez cette commande pour inclure le fichier tarball (\$1.tgz) généré à l'étape précédente dans une seule archive compressée :

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

   Il s'agit du `MyTests.zip` fichier que vous chargez sur Device Farm dans le cadre de la procédure suivante.

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

Python 2  
Générez une archive des packages Python requis (appelé dossier wheelhouse) en utilisant pip :  

```
$ pip wheel --wheel-dir wheelhouse -r requirements.txt
```
Regroupez votre dossier wheelhouse, vos tests et vos exigences concernant pip dans une archive zip pour Device Farm :  

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

Python 3  
Regroupez vos tests et vos exigences concernant pip dans un fichier zip :  

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

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

1. Pour créer un environnement Ruby virtuel, exécutez cette commande :

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

1. Pour utiliser l'environnement que vous venez de créer, exécutez cette commande :

   ```
   rvm gemset use myGemset
   ```

1. Vérifiez votre code source.

   Assurez-vous d'être dans le répertoire racine de votre projet. Vous pouvez voir `Gemfile` dans le répertoire racine.

1. Pour installer vos dépendances locales et toutes les gems à partir du fichier `Gemfile`, exécutez cette commande :

   ```
   bundle install
   ```
**Note**  
À ce stade, vous devriez être en mesure d'exécuter vos tests en local. Pour exécuter un test en local, utilisez cette commande :  

   ```
   bundle exec $test_command
   ```

1. Regroupez vos gems dans le dossier `vendor/cache`.

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

1. Exécutez la commande suivante pour regrouper votre code source, ainsi que toutes vos dépendances, dans une seule archive compressée :

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

   Il s'agit du `MyTests.zip` fichier que vous chargez sur Device Farm dans le cadre de la procédure suivante.

------

## Téléchargez votre package de test sur Device Farm
<a name="test-types-appium-upload"></a>

Vous pouvez utiliser la console Device Farm pour télécharger vos tests.

1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**.

1. Si vous êtes un nouvel utilisateur, choisissez **Nouveau projet**, entrez un nom pour le projet, puis choisissez **Soumettre**.

   Si vous avez déjà un projet, vous pouvez le choisir pour y télécharger vos tests.

1. Ouvrez votre projet, puis choisissez **Create run**.

1. Sous **Paramètres d'exécution**, attribuez un nom approprié à votre test. Il peut contenir n'importe quelle combinaison d'espaces ou de ponctuation.

1.   
Pour les tests natifs Android et iOS  
Sous **Paramètres d'exécution**, choisissez **application Android** si vous testez une application Android (.apk) ou **application iOS** si vous testez une application iOS (.ipa). Ensuite, sous **Sélectionner une application**, sélectionnez **Télécharger votre propre application** pour télécharger le package distribuable de votre application.  
 Le fichier doit être un fichier Android `.apk` ou un fichier iOS `.ipa`. Les applications iOS doivent être construites pour des appareils réels, et non pour le simulateur.   
Pour les tests d'application web mobile  
Sous **Paramètres d'exécution**, sélectionnez **Web App**.

1. Sous **Configurer le test**, dans la section **Sélectionner le framework de test**, choisissez le framework Appium avec lequel vous testez, puis **téléchargez votre propre package de test**.

1. Recherchez et choisissez le fichier .zip contenant vos tests. Le fichier .zip doit respecter le format décrit dans [Configurez votre package de test Appium](#test-types-appium-prepare).

1. Suivez les instructions pour sélectionner les appareils et démarrer l'exécution. Pour de plus amples informations, veuillez consulter [Création d'un test dans Device Farm](how-to-create-test-run.md).

**Note**  
Device Farm ne modifie pas les tests Appium.

## Prenez des captures d'écran de vos tests (facultatif)
<a name="test-types-appium-screenshots"></a>

Vous pouvez effectuer des captures d'écran dans le cadre de vos tests.

Device Farm définit la propriété `DEVICEFARM_SCREENSHOT_PATH` sur un chemin d'accès complet du système de fichiers local, sur lequel Device Farm prévoit que les captures d'écran Appium seront enregistrées. Le répertoire spécifique au test dans lequel les captures d'écran sont stockées est défini lors de l'exécution. Les captures d'écran sont extraites automatiquement dans vos rapports Device Farm. Pour afficher les captures d'écran, dans la console Device Farm, choisissez la section **Screenshots (Captures d'écran)**.

 Pour plus d'informations sur la prise de captures d'écran dans les tests Appium, voir [Take Screenshot](http://appium.io/docs/en/commands/session/screenshot/) dans la documentation Appium API.