

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.

# Création d'un test dans Device Farm
<a name="how-to-create-test-run"></a>

Vous pouvez utiliser la console Device Farm ou l'API Device Farm pour créer un test. AWS CLI Vous pouvez également utiliser un plugin compatible, tel que les plugins Jenkins ou Gradle pour Device Farm. Pour de plus amples informations sur les plug-ins, consultez [Outils et plugins](aws-device-farm-tools-plugins.md). Pour plus d'informations sur les exécutions, consultez [Exécutions](test-runs.md).

**Topics**
+ [Conditions préalables](#how-to-create-test-run-prerequisites)
+ [Création d'un test (console)](#how-to-create-test-run-console)
+ [Créer un test (AWS CLI)](#how-to-create-test-run-cli)
+ [Création d'un test (API)](#how-to-create-test-run-api)
+ [Étapes suivantes](#how-to-create-test-run-console-next-steps)

## Conditions préalables
<a name="how-to-create-test-run-prerequisites"></a>

Vous devez avoir un projet dans Device Farm. Suivez les instructions de [Création d'un projet dans AWS Device Farm](how-to-create-project.md), puis revenez à cette page.

## Création d'un test (console)
<a name="how-to-create-test-run-console"></a>

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

1. Dans le volet de navigation, choisissez **Mobile Device Testing**, puis **Projects**.

1. Si vous disposez déjà d'un projet, vous pouvez charger vos tests dans celui-ci. Sinon, choisissez **Nouveau projet**, entrez un **nom de projet**, puis choisissez **Créer**.

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

1. (Facultatif) Sous **Paramètres d'exécution**, dans la section **Nom de l'exécution**, entrez le nom de votre course. Si aucun nom n'est fourni, la console Device Farm nommera votre course « My Device Farm run » par défaut.

1. (Facultatif) Sous **Paramètres d'exécution**, dans la section **Job timeout**, vous pouvez spécifier le délai d'exécution de votre test. Si vous utilisez un nombre illimité de créneaux de test, vérifiez que **Unmetered** est sélectionné sous Mode **de facturation**.

1. Sous **Paramètres d'exécution**, dans la section **Type d'exécution**, sélectionnez votre type d'exécution. Sélectionnez une **application Android** si aucune application n'est prête à être testée ou si vous testez une application Android (.apk). Sélectionnez une **application iOS** si vous testez une application iOS (.ipa). Sélectionnez **Application Web** si vous souhaitez tester des applications Web.

1. Sous **Sélectionner une application**, dans la section **Options de sélection** des applications, choisissez **Sélectionner un exemple d'application fourni par Device Farm** si aucune application n'est disponible pour les tests. Si vous apportez votre propre application, sélectionnez **Télécharger votre propre application**, puis choisissez votre fichier de candidature. Si vous chargez une application iOS, veillez à choisir **iOS device (Appareil iOS)** et non un simulateur.

1. Sous **Configurer le test**, choisissez l'un des frameworks de test disponibles.
**Note**  
Si vous ne disposez d'aucun test disponible, choisissez **Built-in: Fuzz (Fuzz intégré)** pour exécuter une suite de tests intégrée standard. Si vous choisissez **Built-in: Fuzz (Fuzz intégré)** et que les zones **Event count (Nombre d'événements)**, **Event throttle (Limitation d'événement)** et **Randomizer seed (Valeur initiale de générateur aléatoire)** s'affichent, vous pouvez modifier ou conserver les valeurs. 

   Pour plus d'informations sur les suites de tests disponibles, consultez [Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md).

1. Si vous n'avez pas sélectionné **Built-in : Fuzz**, sélectionnez **Choisir un fichier** sous **Sélectionner un package de test**. Naviguez jusqu'au fichier contenant vos tests et choisissez-le.

1. Pour votre environnement de test, choisissez **Exécuter votre test dans notre environnement standard** ou **Exécuter votre test dans un environnement personnalisé**. Pour de plus amples informations, veuillez consulter [Environnements de test dans AWS Device Farm](test-environments.md).

1. Si vous utilisez un environnement de test personnalisé, vous pouvez éventuellement effectuer les opérations suivantes :
   + Si vous souhaitez modifier la spécification de test par défaut dans un environnement de test personnalisé, choisissez **Edit (Modifier)** pour mettre à jour la spécification YAML par défaut.
   + Si vous avez modifié la spécification de test, choisissez **Enregistrer en tant que nouveau** pour la mettre à jour.
   + Vous pouvez configurer des variables d'environnement. Les variables fournies ici auront priorité sur celles qui peuvent être configurées sur le projet parent.

1. Sous **Sélectionner les appareils**, effectuez l'une des opérations suivantes :
   + Pour choisir un groupe d'appareils intégré sur lequel exécuter les tests, pour **Device pool (Groupe d'appareils)**, choisissez **Top Devices (Principaux appareils)**. 
   + Pour créer votre propre groupe d'appareils sur lequel exécuter les tests, suivez les instructions fournies dans [Création d'un pool d'appareils](how-to-create-device-pool.md), puis revenez à cette page.
   + Si vous avez créé votre propre groupe d'appareils précédemment, pour **Device pool (Groupe d'appareils)**, choisissez votre groupe d'appareils. 
   + Sélectionnez **Sélectionner manuellement les appareils** et choisissez les appareils que vous souhaitez utiliser. Cette configuration ne sera pas enregistrée.

   Pour de plus amples informations, veuillez consulter [Prise en charge des appareils dans AWS Device FarmDevices](devices.md).

1. (Facultatif) Pour ajouter une configuration supplémentaire, ouvrez le menu déroulant **Configuration supplémentaire**. Dans cette section, vous pouvez effectuer l'une des opérations suivantes :
   + Pour fournir un ARN de rôle d'exécution ou remplacer un ARN configuré dans le projet parent, utilisez le champ ARN du rôle d'exécution.
   + Pour fournir d'autres données à utiliser par Device Farm pendant l'exécution, à côté de **Ajouter des données supplémentaires**, **choisissez Choose File**, puis naviguez jusqu'au fichier .zip contenant les données et sélectionnez-le.
   + Pour installer une application supplémentaire que Device Farm pourra utiliser pendant l'exécution, à côté de **Installer d'autres applications**, **choisissez Choose File**, puis recherchez et choisissez le fichier .apk ou .ipa contenant l'application. Répétez cette procédure pour les autres applications que vous voulez installer. Vous pouvez modifier l'ordre d'installation en faisant glisser et en déposant les applications après les avoir chargées. 
   + Pour spécifier si le Wi-Fi, le Bluetooth, le GPS ou le NFC doivent être activés pendant l'exécution, en regard de **Set radio states (Définir les états radio)**, cochez les cases appropriées.
   + Pour prédéfinir la latitude et la longitude de l'appareil pour l'exécution, saisissez les coordonnées en regard de **Device location (Emplacement de l'appareil)**.
   + Pour prédéfinir les paramètres régionaux de l'appareil pour l'exécution, dans Paramètres **régionaux de l'appareil**, choisissez les paramètres régionaux.
   + Sélectionnez **Activer l'enregistrement vidéo** pour enregistrer une vidéo pendant le test.
   + Sélectionnez **Activer la capture des données de performance des applications** pour capturer les données de performance de l'appareil.
**Note**  
Le réglage de l'état radio et des paramètres régionaux de l'appareil ne sont actuellement disponibles que pour les tests natifs d'Android.
**Note**  
Si vous avez des appareils privés, la configuration spécifique aux appareils privés est également affichée.

1. Au bas de la page, choisissez **Create run** pour planifier l'exécution.

Device Farm démarre l'exécution dès que les appareils sont disponibles, généralement en quelques minutes. Pendant votre test, la console Device Farm affiche une icône en attente ![Device Farm scheduled a job.](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-calendar.png) dans le tableau des exécutions. Chaque appareil en cours d'exécution démarrera également par l'icône en attente, puis passera à l'icône en cours d'exécution ![Device Farm progress indicator.](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-progress.png) lorsque le test débutera. À la fin de chaque test, une icône de résultat de test s'affiche à côté du nom de l'appareil. Lorsque tous les tests sont terminés, l'icône en attente à côté de l'exécution devient une icône de résultat de test.

Si vous souhaitez arrêter le test, consultez[Arrêter une exécution dans AWS Device Farm](how-to-stop-test-runs.md).

## Créer un test (AWS CLI)
<a name="how-to-create-test-run-cli"></a>

Vous pouvez utiliser le AWS CLI pour créer un essai.

**Topics**
+ [Étape 1 : Choisissez un projet](#how-to-create-test-run-cli-step1)
+ [Étape 2 : Choisissez un pool d'appareils](#how-to-create-test-run-cli-step2)
+ [Étape 3 : Téléchargez votre dossier de candidature](#how-to-create-test-run-cli-step3)
+ [Étape 4 : Téléchargez votre package de scripts de test](#how-to-create-test-run-cli-step4)
+ [Étape 5 : (Facultatif) Téléchargez votre spécification de test personnalisée](#how-to-create-test-run-cli-step5)
+ [Étape 6 : Planifier un test](#how-to-create-test-run-cli-step6)

### Étape 1 : Choisissez un projet
<a name="how-to-create-test-run-cli-step1"></a>

Vous devez associer votre test à un projet Device Farm.

1. Pour répertorier vos projets Device Farm, lancez**list-projects**. Si vous n'avez aucun projet, consultez [Création d'un projet dans AWS Device Farm](how-to-create-project.md).

   Exemple :

   ```
   aws devicefarm list-projects
   ```

   La réponse inclut une liste de vos projets Device Farm.

   ```
   {
       "projects": [
           {
               "name": "MyProject",
               "arn": "arn:aws:devicefarm:us-west-2:123456789101:project:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
               "created": 1503612890.057
           }
       ]
   }
   ```

1. Choisissez un projet à associer à votre exécution de test et notez son Amazon Resource Name (ARN).

### Étape 2 : Choisissez un pool d'appareils
<a name="how-to-create-test-run-cli-step2"></a>

Vous devez choisir un groupe d'appareils à associer à votre exécution de test.

1. Pour afficher vos groupes d'appareils, exécutez la commande **list-device-pools** en spécifiant l'ARN de votre projet.

   Exemple :

   ```
   aws devicefarm list-device-pools --arn {{arn:MyProjectARN}}
   ```

   La réponse inclut les pools de périphériques Device Farm intégrés, tels que**Top Devices**, et tous les pools de périphériques créés précédemment pour ce projet :

   ```
   {
       "devicePools": [
           {
               "rules": [
                   {
                       "attribute": "ARN",
                       "operator": "IN",
                       "value": "[\"arn:aws:devicefarm:us-west-2::device:example1\",\"arn:aws:devicefarm:us-west-2::device:example2\",\"arn:aws:devicefarm:us-west-2::device:example3\"]"
                   }
               ],
               "type": "CURATED",
               "name": "Top Devices",
               "arn": "arn:aws:devicefarm:us-west-2::devicepool:example",
               "description": "Top devices"
           },
           {
               "rules": [
                   {
                       "attribute": "PLATFORM",
                       "operator": "EQUALS",
                       "value": "\"ANDROID\""
                   }
               ],
               "type": "PRIVATE",
               "name": "MyAndroidDevices",
               "arn": "arn:aws:devicefarm:us-west-2:605403973111:devicepool:example2"
           }
       ]
   }
   ```

1. Choisissez un groupe d'appareils et notez son ARN.

   Vous pouvez également créer un groupe d'appareils, puis revenir à cette étape. Pour de plus amples informations, veuillez consulter [Création d'un pool d'appareils (AWS CLI)](how-to-create-device-pool.md#how-to-create-device-pool-cli).

### Étape 3 : Téléchargez votre dossier de candidature
<a name="how-to-create-test-run-cli-step3"></a>

Pour créer votre demande de téléchargement et obtenir une URL de téléchargement présignée Amazon Simple Storage Service (Amazon S3), vous devez :
+ Votre ARN de projet.
+ Le nom de votre fichier d'application
+ Le type de chargement

Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html).

1. Pour charger un fichier, exécutez la commande **create-upload** avec les paramètres `–-project-arn`, `--name` et `--type`.

   Cet exemple crée un chargement pour une application Android :

   ```
   aws devicefarm create-upload -–project-arn arn:MyProjectArn -–name {{MyAndroid.apk}} -–type ANDROID_APP
   ```

   La réponse inclut l'ARN de chargement de l'application et une URL présignée.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Notez l'ARN de chargement de l'application et l'URL présignée.

1. Chargez le fichier de votre application à l'aide de l'URL présignée Amazon S3. Cet exemple utilise **curl** pour charger un fichier .apk Android :

   ```
   curl -T MyAndroid.apk "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

   Pour plus d'informations, consultez la section [Chargement d'objets à l'aide de Presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) dans le guide de l'*utilisateur d'Amazon Simple Storage Service*.

1. Pour vérifier l'état de votre chargement d'application, exécutez **get-upload** et spécifiez l'ARN de chargement de l'application.

   ```
   aws devicefarm get-upload –-arn arn:MyAppUploadARN
   ```

   Attendez que l'état de la réponse soit **SUCCEEDED** avant de charger votre package de scripts de test.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Étape 4 : Téléchargez votre package de scripts de test
<a name="how-to-create-test-run-cli-step4"></a>

Ensuite, chargez votre package de scripts de test.

1. Pour créer votre demande de téléchargement et obtenir une URL de téléchargement présignée Amazon S3, exécutez **create-upload** avec les `--type` paramètres `–-project-arn``--name`, et.

   Cet exemple crée un chargement de package de test Appium Java TestNG :

   ```
   aws devicefarm create-upload –-project-arn {{arn:MyProjectARN}} -–name {{MyTests.zip}} –-type APPIUM_JAVA_TESTNG_TEST_PACKAGE
   ```

   La réponse inclut l'ARN de chargement de votre package de test et une URL présignée.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }    
   }
   ```

1. Notez l'ARN de chargement du package de test et l'URL présignée.

1. Téléchargez le fichier de package de vos scripts de test à l'aide de l'URL présignée Amazon S3. Cet exemple utilise **curl** pour charger un fichier compressé de scripts Appium TestNG :

   ```
   curl -T MyTests.zip "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Pour vérifier l'état du chargement de votre package de scripts de test, exécutez **get-upload** et spécifiez l'ARN de chargement du package de test, obtenu à l'étape 1.

   ```
   aws devicefarm get-upload –-arn arn:MyTestsUploadARN
   ```

   Attendez que l'état de la réponse soit **SUCCEEDED** avant de passer à l'étape suivante, facultative.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Étape 5 : (Facultatif) Téléchargez votre spécification de test personnalisée
<a name="how-to-create-test-run-cli-step5"></a>

Si vous exécutez vos tests dans un environnement de test standard, ignorez cette étape.

Device Farm gère un fichier de spécifications de test par défaut pour chaque type de test pris en charge. Ensuite, téléchargez votre spécification de test par défaut et utilisez-la pour créer un chargement de spécification de test personnalisée afin d'exécuter vos tests dans un environnement de test personnalisé. Pour de plus amples informations, veuillez consulter [Environnements de test dans AWS Device Farm](test-environments.md).

1. Pour trouver l'ARN de chargement de votre spécification de test par défaut, exécutez la commande **list-uploads** et spécifiez l'ARN de votre projet.

   ```
   aws devicefarm list-uploads --arn {{arn:MyProjectARN}}
   ```

   La réponse contient une entrée pour chaque spécification de test par défaut :

   ```
   {
       "uploads": [
           {
   
               {
                   "status": "SUCCEEDED",
                   "name": "Default TestSpec for Android Appium Java TestNG",
                   "created": 1529498177.474,
                   "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
                   "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
                   "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
               }
           }
       ]
   }
   ```

1. Choisissez votre spécification de test par défaut dans la liste. Notez son ARN de chargement.

1. Pour télécharger votre spécification de test par défaut, exécutez la commande **get-upload** et spécifiez l'ARN de chargement.

   Exemple :

   ```
   aws devicefarm get-upload –-arn {{arn:MyDefaultTestSpecARN}}
   ```

   La réponse contient une URL présignée à laquelle vous pouvez télécharger votre spécification de test par défaut.

1. Cet exemple utilise **curl** pour télécharger la spécification de test par défaut et l'enregistrer sous `MyTestSpec.yml` :

   ```
   curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyTestSpec.yml
   ```

1. Vous pouvez modifier la spécification de test par défaut pour qu'elle réponde à vos exigences en matière de test, puis utiliser votre spécification de test modifiée lors des futures exécutions de test. Ignorez cette étape pour utiliser la spécification de test par défaut en l'état dans un environnement de test personnalisé. 

1. Pour créer un chargement de votre spécification de test personnalisée, exécutez la commande **create-upload** en spécifiant le nom de votre spécification de test, le type de spécification de test et l'ARN du projet.

   Cet exemple crée un chargement pour une spécification de test personnalisée Appium Java TestNG :

   ```
   aws devicefarm create-upload --name MyTestSpec.yml --type APPIUM_JAVA_TESTNG_TEST_SPEC --project-arn {{arn:MyProjectARN}}
   ```

   La réponse inclut l'ARN de chargement de la spécification de test et une URL présignée :

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "category": "PRIVATE",
           "name": "MyTestSpec.yml",
           "created": 1535751101.221,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Notez l'ARN de chargement de la spécification de test et l'URL présignée.

1. Téléchargez votre fichier de spécifications de test à l'aide de l'URL présignée Amazon S3. Cet exemple permet **curl** de télécharger une spécification de test Appium JavaTest NG :

   ```
   curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Pour vérifier l'état de votre chargement de spécification de test, exécutez **get-upload** et spécifiez l'ARN de chargement.

   ```
   aws devicefarm get-upload –-arn {{arn:MyTestSpecUploadARN}}
   ```

   Attendez que l'état de la réponse soit **SUCCEEDED** avant de planifier l'exécution de votre test.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTestSpec.yml",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

   Pour mettre à jour votre spécification de test personnalisée, exécutez la commande **update-upload** en spécifiant l'ARN de chargement de la spécification de test. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html).

### Étape 6 : Planifier un test
<a name="how-to-create-test-run-cli-step6"></a>

Pour planifier un test avec le AWS CLI**schedule-run**, exécutez en spécifiant :
+ L'ARN du projet, obtenu à l'[étape 1](#how-to-create-test-run-cli-step1)
+ L'ARN du groupe d'appareils, obtenu à l'[étape 2](#how-to-create-test-run-cli-step2)
+ L'ARN de chargement de l'application, obtenu à l'[étape 3](#how-to-create-test-run-cli-step3)
+ L'ARN de chargement du package de test, obtenu à l'[étape 4](#how-to-create-test-run-cli-step4)

 Si vous exécutez des tests dans un environnement de test personnalisé, vous avez également besoin de l'ARN de votre spécification de test, obtenu à l'[étape 5](#how-to-create-test-run-cli-step5).

**Pour planifier une exécution dans un environnement de test standard**
+ Exécutez la commande **schedule-run** en spécifiant l'ARN de votre projet, l'ARN du groupe d'appareils, l'ARN de chargement de l'application et les informations sur le package de test.

  Exemple :

  ```
  aws devicefarm schedule-run --project-arn {{arn:MyProjectARN}} --app-arn {{arn:MyAppUploadARN}} --device-pool-arn {{arn:MyDevicePoolARN}} --name {{MyTestRun}} --test type=APPIUM_JAVA_TESTNG,testPackageArn={{arn:MyTestPackageARN}}
  ```

  La réponse contient un ARN d'exécution que vous pouvez utiliser pour vérifier l'état de votre exécution de test.

  ```
  {
      "run": {
          "status": "SCHEDULING",
          "appUpload": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345appEXAMPLE",
          "name": "MyTestRun",
          "radios": {
              "gps": true,
              "wifi": true,
              "nfc": true,
              "bluetooth": true
          },
          "created": 1535756712.946,
          "totalJobs": 179,
          "completedJobs": 0,
          "platform": "ANDROID_APP",
          "result": "PENDING",
          "devicePoolArn": "arn:aws:devicefarm:us-west-2:123456789101:devicepool:5e01a8c7-c861-4c0a-b1d5-12345devicepoolEXAMPLE",
          "jobTimeoutMinutes": 150,
          "billingMethod": "METERED",
          "type": "APPIUM_JAVA_TESTNG",
          "testSpecArn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345specEXAMPLE",
          "arn": "arn:aws:devicefarm:us-west-2:123456789101:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE",
          "counters": {
              "skipped": 0,
              "warned": 0,
              "failed": 0,
              "stopped": 0,
              "passed": 0,
              "errored": 0,
              "total": 0
          }
      }
  }
  ```

  Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html).

**Pour planifier une exécution dans un environnement de test personnalisé**
+ Les étapes sont presque identiques à celles à suivre pour l'environnement de test standard, avec un attribut supplémentaire `testSpecArn` inclus dans le paramètre `--test`.

  Exemple :

  ```
  aws devicefarm schedule-run --project-arn {{arn:MyProjectARN}} --app-arn {{arn:MyAppUploadARN}} --device-pool-arn {{arn:MyDevicePoolARN}} --name {{MyTestRun}} --test testSpecArn={{arn:MyTestSpecUploadARN}},type={{APPIUM_JAVA_TESTNG}},testPackageArn={{arn:MyTestPackageARN}}
  ```

**Pour vérifier l'état de votre exécution de test**
+ Utilisez la commande **get-run** et spécifiez l'ARN d'exécution :

  ```
  aws devicefarm get-run --arn arn:aws:devicefarm:us-west-2:111122223333:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE
  ```

Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html). Pour plus d'informations sur l'utilisation de Device Farm avec le AWS CLI, consultez[AWS CLI référence](cli-ref.md).

## Création d'un test (API)
<a name="how-to-create-test-run-api"></a>

Les étapes sont les mêmes que celles décrites dans la AWS CLI section. Consultez [Créer un test (AWS CLI)](#how-to-create-test-run-cli).

Vous avez besoin des informations suivantes pour appeler l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html) :
+ L'ARN d'un projet. Consultez [Création d'un projet (API)](how-to-create-project.md#how-to-create-project-api) et [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html).
+ L'ARN de chargement d'une application. Consultez [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ L'ARN de chargement d'un package de test. Consultez [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ L'ARN d'un groupe d'appareils. Consultez [Création d'un pool d'appareils](how-to-create-device-pool.md) et [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).

**Note**  
Si vous exécutez des tests dans un environnement de test personnalisé, vous avez également besoin de l'ARN de chargement de votre spécification de test. Pour plus d’informations, consultez [Étape 5 : (Facultatif) Téléchargez votre spécification de test personnalisée](#how-to-create-test-run-cli-step5) et [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).

Pour plus d'informations sur l'utilisation de l'API Device Farm, consultez[Automatiser Device Farm](api-ref.md).

## Étapes suivantes
<a name="how-to-create-test-run-console-next-steps"></a>

Dans la console Device Farm, l'icône de l'horloge ![Device Farm scheduled a job.](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-calendar.png) devient une icône de résultat, telle que celle de succès une ![The test succeeded.](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-success.png) fois l'exécution terminée. Un rapport sur l'exécution s'affiche dès que les tests sont terminés. Pour de plus amples informations, veuillez consulter [Rapports dans AWS Device FarmRapports](reports.md).

Pour utiliser ce rapport, suivez les instructions fournies dans [Afficher les rapports de test dans Device Farm](how-to-use-reports.md).