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.
# Tests exécutés dans AWS Device Farm
Une exécution dans Device Farm représente une version spécifique de votre application, avec un ensemble spécifique de tests, à exécuter sur un ensemble spécifique d'appareils. Une exécution produit un rapport contenant des informations sur les résultats de l'exécution. Une exécution contient une ou plusieurs tâches. Pour de plus amples informations, veuillez consulter [Exécutions](test-runs.md).
Vous pouvez utiliser la console AWS Device Farm AWS Command Line Interface (AWS CLI) ou l'API AWS Device Farm pour effectuer des tests.
**Topics**
+ [Création d'un test dans Device Farm](how-to-create-test-run.md)
+ [Définition du délai d'exécution pour les tests dans AWS Device Farm](how-to-set-default-timeout-for-test-runs.md)
+ [Simulation des connexions réseau et des conditions pour les exécutions de votre AWS Device Farm](how-to-simulate-network-connections-and-conditions.md)
+ [Arrêter une exécution dans AWS Device Farm](how-to-stop-test-runs.md)
+ [Afficher la liste des exécutions dans AWS Device Farm](how-to-view-runs-list.md)
+ [Création d'un pool d'appareils dans AWS Device Farm](how-to-create-device-pool.md)
+ [Analyse des résultats des tests dans AWS Device Farm](analyzing-results.md)
# Création d'un test dans Device Farm
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
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)
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 sur lesquels vous souhaitez vous lancer. 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 naviguez jusqu'au fichier .apk ou .ipa qui contient l'application et sélectionnez-le. 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)
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
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
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
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
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
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
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)
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
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).
# Définition du délai d'exécution pour les tests dans AWS Device Farm
Vous pouvez définir une valeur de durée d'exécution des tests avant d'empêcher chaque appareil d'exécuter un test. Le délai d'exécution par défaut est de 150 minutes par appareil, mais vous pouvez définir une valeur de seulement 5 minutes. Vous pouvez utiliser la console AWS Device Farm ou AWS CLI l'API AWS Device Farm pour définir le délai d'exécution.
**Important**
L'option de délai d'exécution doit être définie sur la *durée maximale* d'une exécution de test, plus un tampon. Par exemple, si vos tests prennent 20 minutes par appareil, vous devez choisir un délai d'exécution de 30 minutes par appareil.
Si l'exécution dépasse le délai, elle est arrêtée de force sur l'appareil concerné. Des résultats partiels sont disponibles, si possible. Vous êtes facturé à hauteur de la durée d'exécution si vous avez choisi le mode de facturation limité. Pour plus d'informations sur les tarifs, consultez [Device Farm Pricing](https://aws.amazon.com/device-farm/pricing/).
Vous souhaiterez peut-être utiliser cette fonction si vous savez combien de temps l'exécution de test doit prendre sur chaque appareil. La définition d'un délai d'exécution pour une exécution de test vous permet d'éviter de vous retrouver avec une exécution de test bloquée pour une raison quelconque et d'être facturé pour des minutes passées sur l'appareil pendant lesquelles aucun test n'est exécuté. Autrement dit, la fonction de délai d'exécution vous permet d'arrêter l'exécution si elle prend plus de temps que prévu.
Vous pouvez définir le délai d'exécution à deux niveaux : celui du projet et celui de l'exécution de test.
## Conditions préalables
1. Suivez les étapes de [Configuration](setting-up.md).
1. Créez 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.
## Définir le délai d'exécution d'un projet
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 avez déjà un projet, sélectionnez-le dans la liste. Sinon, choisissez **Nouveau projet**, entrez un nom pour votre projet, puis choisissez **Soumettre**.
1. Choisissez **Project settings (Paramètres du projet)**.
1. Sous l'onglet **General (Général)**, pour **Execution timeout (Délai d'exécution)**, entrez une valeur ou utilisez la barre du curseur.
1. Choisissez **Enregistrer**.
Toutes les exécutions de test de votre projet utilisent désormais la valeur de délai d'exécution que vous avez spécifiée, sauf si vous la remplacez lorsque vous planifiez une exécution.
## Définissez le délai d'exécution d'un test
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 avez déjà un projet, sélectionnez-le dans la liste. Sinon, choisissez **Nouveau projet**, entrez un nom pour votre projet, puis choisissez **Soumettre**.
1. Choisissez **Create a new run (Créer une exécution)**.
1. Suivez les étapes ci-dessous pour choisir une application, configurer votre test, sélectionner vos appareils et spécifier un état d'appareil.
1. Dans **Révision et lancement de l'exécution****, pour Définir le délai d'exécution**, entrez une valeur ou utilisez le curseur.
1. Choisissez **Confirm and start run (Confirmer et démarrer l'exécution)**.
# Simulation des connexions réseau et des conditions pour les exécutions de votre AWS Device Farm
Vous pouvez utiliser le modelage du réseau pour simuler les connexions et les conditions du réseau lorsque vous testez vos applications Android, iOS et Web dans Device Farm. Par exemple, vous pouvez simuler une connexion Internet intermittente ou avec perte.
Lorsque vous créez une exécution en utilisant les paramètres réseau par défaut, chaque appareil dispose d'une connexion Wi-Fi complète, intègre, avec une connectivité Internet. Lorsque vous utilisez le modelage du réseau, vous pouvez modifier la connexion Wi-Fi pour spécifier un profil réseau tel que **3G** ou **Lossy WiFi** qui contrôle le débit, le délai, l'instabilité et les pertes pour le trafic entrant et sortant.
**Topics**
+ [Configurer le modelage du réseau lors de la planification d'un test](#network-shaping-how-to-choose-a-curated-profile-when-scheduling-a-test-run)
+ [Création d'un profil réseau](#network-shaping-how-to-create-a-network-profile)
+ [Modifier les conditions du réseau pendant votre test](#change-network-conditions-during-test)
## Configurer le modelage du réseau lors de la planification d'un test
Lorsque vous planifiez une course, vous pouvez choisir l'un des profils sélectionnés par Device Farm, ou vous pouvez créer et gérer le vôtre.
1. Dans n'importe quel projet Device Farm, choisissez **Create a new run**.
Si vous n'avez pas encore de projet, consultez [Création d'un projet dans AWS Device Farm](how-to-create-project.md).
1. Choisissez votre application, puis cliquez sur **Suivant**.
1. Configurez votre test, puis choisissez **Next**.
1. Sélectionnez vos appareils, puis cliquez sur **Suivant**.
1. Dans la section **Emplacement et paramètres réseau**, choisissez un profil réseau ou choisissez **Créer un profil réseau** pour créer le vôtre.
![\[Profil réseau pour une exécution de test\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-set-up-network-profile.png)
1. Choisissez **Suivant**.
1. Vérifiez et démarrez votre exécution de test.
## Création d'un profil réseau
Lorsque vous créez une exécution de test, vous pouvez créer un profil réseau.
1. Choisissez **Créer un profil réseau**.
![\[Créer un profil réseau\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-create-a-new-network-profile.png)
1. Entrez le nom et les paramètres de votre profil réseau.
1. Choisissez **Créer**.
1. Terminez la création de votre exécution de test et démarrez l'exécution.
Après avoir créé un profil réseau, vous pourrez le voir et le gérer sur la page **Project settings (Paramètres du projet)**.
![\[Profils réseau dans la page des paramètres du projet\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-network-profiles-in-project-settings.png)
## Modifier les conditions du réseau pendant votre test
Vous pouvez appeler une API depuis l'hôte de votre appareil à l'aide d'un framework tel qu'Appium pour simuler des conditions de réseau dynamiques telles qu'une réduction de la bande passante pendant votre essai. Pour de plus amples informations, veuillez consulter [CreateNetworkProfile](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateNetworkProfile.html).
# Arrêter une exécution dans AWS Device Farm
Vous voudrez peut-être arrêter une exécution après l'avoir démarrée. Par exemple, si vous remarquez un problème pendant que vos tests s'exécutent, vous voudrez peut-être redémarrer l'exécution avec un script de test mis à jour.
Vous pouvez utiliser la console Device Farm ou l'API pour arrêter une exécution. AWS CLI
**Topics**
+ [Arrêter une exécution (console)](#how-to-stop-run-console)
+ [Arrêtez une course (AWS CLI)](#how-to-stop-test-run-cli)
+ [Arrêter une exécution (API)](#how-to-stop-test-run-api)
## Arrêter une exécution (console)
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. Choisissez le projet pour lequel vous effectuez un test actif.
1. Sur la page **Tests automatisés**, choisissez l'exécution du test.
L'icône en attente ou en cours d'exécution doit apparaître à gauche du nom de l'appareil.
![\[Device Farm - Arrêter une exécution de test\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-stop-run.png)
1. Choisissez **Stop run (Arrêter l'exécution)**.
Après un court instant, une icône avec un cercle rouge avec un signe négatif à l'intérieur apparaît à côté du nom de l'appareil. Lorsque la course est arrêtée, la couleur de l'icône passe du rouge au noir.
**Important**
Si un test a déjà été effectué, Device Farm ne peut pas l'arrêter. Si un test est en cours, Device Farm l'arrête. Le nombre total de minutes qui vous sera facturé s'affiche dans la section **Devices (Appareils)**. En outre, vous serez également facturé pour le nombre total de minutes nécessaires à Device Farm pour exécuter la suite de configuration et la suite de démontage. Pour plus d'informations, consultez [Tarification de Device Farm](https://aws.amazon.com/device-farm/faq/#pricing).
L'image suivante montre un exemple de la section **Devices (Appareils)** après l'arrêt réussi d'une exécution de test.
![\[Device Farm - Page détaillée d'une exécution arrêtée\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/aws-device-farm-stop-run-view-details.png)
## Arrêtez une course (AWS CLI)
Vous pouvez exécuter la commande suivante pour arrêter le test spécifié, où *myARN* est le nom de ressource Amazon (ARN) du test.
```
$ aws devicefarm stop-run --arn myARN
```
Vous devez voir des résultats similaires à ce qui suit :
```
{
"run": {
"status": "STOPPING",
"name": "Name of your run",
"created": 1458329687.951,
"totalJobs": 7,
"completedJobs": 5,
"deviceMinutes": {
"unmetered": 0.0,
"total": 0.0,
"metered": 0.0
},
"platform": "ANDROID_APP",
"result": "PENDING",
"billingMethod": "METERED",
"type": "BUILTIN_EXPLORER",
"arn": "myARN",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 0,
"errored": 0,
"total": 0
}
}
}
```
Pour obtenir l'ARN de votre exécution, utilisez la commande `list-runs`. La sortie doit ressembler à ce qui suit :
```
{
"runs": [
{
"status": "RUNNING",
"name": "Name of your run",
"created": 1458329687.951,
"totalJobs": 7,
"completedJobs": 5,
"deviceMinutes": {
"unmetered": 0.0,
"total": 0.0,
"metered": 0.0
},
"platform": "ANDROID_APP",
"result": "PENDING",
"billingMethod": "METERED",
"type": "BUILTIN_EXPLORER",
"arn": "Your ARN will be here",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 0,
"errored": 0,
"total": 0
}
}
]
}
```
Pour plus d'informations sur l'utilisation de Device Farm avec le AWS CLI, consultez[AWS CLI référence](cli-ref.md).
## Arrêter une exécution (API)
+ Appelez l'[StopRun](../../latest/APIReference/API_StopRun.html)opération au test.
Pour plus d'informations sur l'utilisation de l'API Device Farm, consultez[Automatiser Device Farm](api-ref.md).
# Afficher la liste des exécutions dans AWS Device Farm
Vous pouvez utiliser la console Device Farm ou l'API pour afficher la liste des exécutions d'un projet. AWS CLI
**Topics**
+ [Afficher la liste des exécutions (console)](#how-to-view-runs-list-console)
+ [Afficher la liste des courses (AWS CLI)](#how-to-view-runs-list-cli)
+ [Afficher la liste des exécutions (API)](#how-to-view-runs-list-api)
## Afficher la liste des exécutions (console)
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. Dans la liste des projets, choisissez le projet correspondant à la liste d'exécutions que vous souhaitez afficher.
**Astuce**
Vous pouvez utiliser la barre de recherche pour filtrer la liste des projets par nom.
## Afficher la liste des courses (AWS CLI)
+ Exécutez la commande [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html).
Pour afficher des informations sur une seule exécution, exécutez la commande [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).
## Afficher la liste des exécutions (API)
+ Appelez l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html).
Pour afficher des informations sur une seule exécution, appelez l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html).
Pour plus d'informations sur l'API Device Farm, consultez[Automatiser Device Farm](api-ref.md).
# Création d'un pool d'appareils dans AWS Device Farm
Vous pouvez utiliser la console Device Farm ou AWS CLI l'API pour créer un pool d'appareils.
**Topics**
+ [Conditions préalables](#how-to-create-device-pool-prerequisites)
+ [Création d'un pool d'appareils (console)](#how-to-create-device-pool-console)
+ [Création d'un pool d'appareils (AWS CLI)](#how-to-create-device-pool-cli)
+ [Création d'un pool d'appareils (API)](#how-to-create-device-pool-api)
## Conditions préalables
+ Créez une exécution dans la console Device Farm. Suivez les instructions de la section [Création d'un test dans Device Farm](how-to-create-test-run.md). Lorsque vous accédez à la page **Select devices (Sélectionner les appareils)**, suivez les instructions fournies dans cette section.
## Création d'un pool d'appareils (console)
1. Sur la page **Projets**, choisissez votre projet. Sur la page **Détails du projet**, sélectionnez **Paramètres du projet**. Dans l'onglet **Device pools**, choisissez **Create Device Pool**.
1. Pour **Name (Nom)**, saisissez un nom permettant d'identifier facilement ce groupe d'appareils.
1. Pour **Description**, saisissez une description permettant d'identifier facilement ce groupe d'appareils.
1. Si vous souhaitez utiliser un ou plusieurs critères de sélection pour les appareils de ce groupe, procédez comme suit :
1. Choisissez **Créer un pool de périphériques dynamique**.
1. Choisissez **Ajouter une règle**.
1. Pour **Champ** (première liste déroulante), sélectionnez l'une des options suivantes :
+ Pour inclure les appareils par leur nom de fabricant, sélectionnez **Device Manufacturer**.
+ Pour inclure les appareils en fonction de leur format (tablette ou téléphone), choisissez **Form Factor**.
+ Pour inclure les appareils en fonction de leur état de disponibilité en fonction de la charge, sélectionnez **Disponibilité**.
+ Pour inclure uniquement les appareils publics ou privés, choisissez le **type de flotte**.
+ Pour inclure les appareils en fonction de leur système d'exploitation, choisissez **Platform**.
+ Certains appareils sont dotés d'une étiquette ou d'une description supplémentaire à propos de l'appareil. Vous pouvez rechercher les appareils en fonction du contenu de leur étiquette en choisissant **Étiquettes d'instance**.
+ Pour inclure les appareils en fonction de leur version du système d'exploitation, choisissez Version du système d'**exploitation**.
+ Pour inclure les appareils en fonction de leur modèle, sélectionnez **Modèle**.
1. Pour **Opérateur** (deuxième liste déroulante), choisissez une opération logique (EQUALS, CONTAINS, etc.) pour inclure les appareils en fonction de la requête. Par exemple, vous pouvez choisir *Availability EQUALS AVAILABLE* d'inclure les appareils qui ont actuellement le `Available` statut.
1. Pour **Valeur** (troisième liste déroulante), entrez ou choisissez la valeur que vous souhaitez spécifier pour les valeurs de **champ** et d'**opérateur**. Les valeurs sont limitées en fonction de votre choix de **champ**. Par exemple, si vous choisissez **Platform** for **Field**, les seules sélections disponibles sont **ANDROID** et **IOS**. De même, si vous choisissez **Form Factor** pour **Field**, les seules sélections disponibles sont **TÉLÉPHONE** et **TABLETTE**.
1. Pour ajouter une autre règle, choisissez **Ajouter une règle**.
Une fois que vous avez créé la première règle, dans la liste des appareils, la case en regard de chaque appareil correspondant à cette règle est activée. Une fois que vous avez créé ou modifié des règles, dans la liste des appareils, la case en regard de chaque appareil correspondant à ces règles combinées est activée. Les appareils dont les cases sont activées sont inclus dans le groupe d'appareils. Les appareils dont les cases sont désactivées sont exclus.
1. Sous Nombre **maximal d'appareils**, entrez le nombre d'appareils que vous souhaitez utiliser dans votre pool d'appareils. Si vous ne saisissez pas le nombre maximum d'appareils, Device Farm sélectionnera tous les appareils du parc qui correspondent aux règles que vous avez créées. Pour éviter des frais supplémentaires, définissez ce chiffre sur un montant correspondant à vos exigences réelles en matière d'exécution parallèle et de variété d'appareils.
1. Pour supprimer une règle, choisissez **Supprimer la règle**.
1. Si vous souhaitez inclure ou exclure manuellement des appareils individuels, procédez comme suit :
1. Choisissez **Créer un pool de périphériques statique**.
1. Cochez ou décochez la case à côté de chaque appareil. Vous ne pouvez activer ou désactiver les cases que si vous n'avez aucune règle spécifiée.
1. Si vous souhaitez inclure ou exclure tous les appareils affichés, activez ou désactivez la case dans la ligne d'en-tête de colonne de la liste. Si vous souhaitez afficher uniquement les instances d'appareils privés, choisissez **Voir uniquement les instances d'appareils privés**.
**Important**
Bien que vous puissiez utiliser les cases de la ligne d'en-tête de colonne pour modifier la liste des appareils affichés, cela ne signifie pas que les autres appareils affichés sont les seuls à être inclus ou exclus. Pour vérifier quels appareils sont inclus ou exclus, veillez à effacer le contenu de toutes les cases dans la ligne d'en-tête de colonne, puis à parcourir les cases.
1. Choisissez **Créer**.
## Création d'un pool d'appareils (AWS CLI)
**Astuce**
Si vous ne saisissez pas le nombre maximum d'appareils, Device Farm sélectionnera tous les appareils du parc qui correspondent aux règles que vous avez créées. Pour éviter des frais supplémentaires, définissez ce chiffre sur un montant correspondant à vos exigences réelles en matière d'exécution parallèle et de variété d'appareils.
+ Exécutez la commande [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-device-pool.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-device-pool.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 pool d'appareils (API)
**Astuce**
Si vous ne saisissez pas le nombre maximum d'appareils, Device Farm sélectionnera tous les appareils du parc qui correspondent aux règles que vous avez créées. Pour éviter des frais supplémentaires, définissez ce chiffre sur un montant correspondant à vos exigences réelles en matière d'exécution parallèle et de variété d'appareils.
+ Appelez l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).
Pour plus d'informations sur l'utilisation de l'API Device Farm, consultez[Automatiser Device Farm](api-ref.md).
# Analyse des résultats des tests dans AWS Device Farm
Dans l'environnement de test standard, vous pouvez utiliser la console Device Farm pour consulter les rapports de chaque test de votre cycle de test. La consultation des rapports vous permet de comprendre quels tests ont été réussis ou ont échoué, et vous fournit des informations détaillées sur les performances et le comportement de votre application sur les différentes configurations d'appareils.
Device Farm rassemble également d'autres artefacts tels que des fichiers, des journaux et des images que vous pouvez télécharger une fois votre test terminé. Ces informations peuvent vous aider à analyser le comportement de votre application sur de vrais appareils, à identifier les problèmes ou les bogues et à diagnostiquer les problèmes.
**Topics**
+ [Afficher les rapports de test dans Device Farm](how-to-use-reports.md)
+ [Téléchargement d'artefacts dans Device Farm](artifacts.md)
# Afficher les rapports de test dans Device Farm
Utilisez la console Device Farm pour consulter vos rapports de test. Pour de plus amples informations, veuillez consulter [Rapports dans AWS Device FarmRapports](reports.md).
**Topics**
+ [Conditions préalables](#how-to-use-reports-prerequisites)
+ [Afficher les rapports](#how-to-use-reports-viewing-reports)
+ [Statuts des résultats des tests Device Farm](how-to-use-reports-displaying-results.md)
## Conditions préalables
Configurez une exécution de test et vérifiez qu'elle est terminée.
1. Pour créer une exécution, consultez [Création d'un test dans Device Farm](how-to-create-test-run.md), puis revenez à cette page.
1. Vérifiez que l'exécution est terminée. 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) pour les exécutions en cours. Chaque appareil en cours d'exécution démarrera également par l'icône en attente, puis passera à l'![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-progress.png)icône en cours d'exécution 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. Pour de plus amples informations, veuillez consulter [Statuts des résultats des tests Device Farm](how-to-use-reports-displaying-results.md).
## Afficher les rapports
Vous pouvez consulter les résultats de votre test dans la console Device Farm.
**Topics**
+ [Afficher la page récapitulative du test](#how-to-use-reports-console-summary)
+ [Afficher des rapports de problèmes uniques](#how-to-use-reports-console-unique-problems)
+ [Afficher les rapports sur les appareils](#how-to-use-reports-console-by-device)
+ [Afficher les rapports de la suite de tests](#how-to-use-reports-console-by-suite)
+ [Affichage des rapports de test](#how-to-use-reports-console-by-test)
+ [Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport](#how-to-use-reports-console-log)
### Afficher la page récapitulative du test
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. Dans la liste des projets, choisissez le projet pour l'exécution.
**Astuce**
Pour filtrer la liste des projets par nom, utilisez la barre de recherche.
1. Choisissez une exécution terminée pour afficher la page de son rapport récapitulatif.
1. La page récapitulative de l'exécution de test affiche une présentation de vos résultats de test.
+ La section **Unique problems (Problèmes uniques)** répertorie les avertissements et échecs uniques. Pour afficher les problèmes uniques, suivez les instructions fournies dans [Afficher des rapports de problèmes uniques](#how-to-use-reports-console-unique-problems).
+ La section **Devices (Appareils)** affiche le nombre total de tests, par résultat, pour chaque appareil.
![\[Device Farm device summary results.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-device-summary-results-bar.png)
Dans cet exemple, il existe plusieurs appareils. Dans la première entrée du tableau, l'appareil Google Pixel 4 XL exécutant la version 10 d'Android signale trois tests réussis dont l'exécution a duré 02:36 minutes.
Pour afficher les résultats par appareil, suivez les instructions fournies dans [Afficher les rapports sur les appareils](#how-to-use-reports-console-by-device).
+ La section **Captures d'écran** affiche la liste de toutes les captures d'écran capturées par Device Farm pendant l'exécution, regroupées par appareil.
+ Dans la section **Résultat de l'analyse**, vous pouvez télécharger le résultat de l'analyse.
### Afficher des rapports de problèmes uniques
1. Dans **Unique problems (Problèmes uniques)**, choisissez le problème que vous souhaitez afficher.
1. Choisissez l'appareil. Le rapport affiche des informations sur le problème.
La section **Video (Vidéo)** affiche un enregistrement vidéo téléchargeable du test.
La section **Résultat** affiche le résultat du test. Le statut est représenté par une icône de résultat. Pour de plus amples informations, veuillez consulter [Statuts d'un test individuel](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
La section **Logs** affiche toutes les informations enregistrées par Device Farm pendant le test. Pour afficher ces informations, suivez les instructions fournies dans [Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport](#how-to-use-reports-console-log).
L'onglet **Fichiers** affiche la liste de tous les fichiers associés au test (tels que les fichiers journaux) que vous pouvez télécharger. Pour télécharger un fichier, cliquez sur le lien du fichier dans la liste.
L'onglet **Captures d'écran** affiche la liste de toutes les captures d'écran capturées par Device Farm pendant le test.
### Afficher les rapports sur les appareils
+ Dans la section **Devices (Appareils)**, choisissez l'appareil.
La section **Video (Vidéo)** affiche un enregistrement vidéo téléchargeable du test.
La section **Suites** affiche un tableau contenant des informations sur les suites de l'appareil.
Dans ce tableau, la colonne **Résultats des tests** récapitule le nombre de tests par résultat pour chacune des suites de tests exécutées sur le périphérique. Ces données comportent également une composante graphique. Pour de plus amples informations, veuillez consulter [Statuts pour plusieurs tests](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Pour afficher les résultats complets par suite, suivez les instructions figurant dans[Afficher les rapports de la suite de tests](#how-to-use-reports-console-by-suite).
La section **Logs** affiche toutes les informations que Device Farm a enregistrées pour l'appareil pendant l'exécution. Pour afficher ces informations, suivez les instructions fournies dans [Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport](#how-to-use-reports-console-log).
La section **Fichiers** affiche la liste des suites pour l'appareil et tous les fichiers associés (tels que les fichiers journaux) que vous pouvez télécharger. Pour télécharger un fichier, cliquez sur le lien du fichier dans la liste.
La section **Captures d'écran** affiche la liste de toutes les captures d'écran capturées par Device Farm pendant l'exécution de l'appareil, regroupées par suite.
### Afficher les rapports de la suite de tests
1. Dans la section **Devices (Appareils)**, choisissez l'appareil.
1. Dans la section **Suites**, choisissez la suite dans le tableau.
La section **Video (Vidéo)** affiche un enregistrement vidéo téléchargeable du test.
La section **Tests** affiche un tableau contenant des informations sur les tests de la suite.
Dans le tableau, la colonne **Résultats du test** affiche le résultat. Ces données comportent également une composante graphique. Pour de plus amples informations, veuillez consulter [Statuts pour plusieurs tests](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Pour afficher les résultats complets par test, suivez les instructions de[Affichage des rapports de test](#how-to-use-reports-console-by-test).
La section **Logs** affiche toutes les informations enregistrées par Device Farm lors de l'exécution de la suite. Pour afficher ces informations, suivez les instructions fournies dans [Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport](#how-to-use-reports-console-log).
La section **Fichiers** affiche la liste des tests pour la suite et tous les fichiers associés (tels que les fichiers journaux) que vous pouvez télécharger. Pour télécharger un fichier, cliquez sur le lien du fichier dans la liste.
La section **Captures d'écran** affiche une liste de toutes les captures d'écran capturées par Device Farm lors de l'exécution de la suite, regroupées par test.
### Affichage des rapports de test
1. Dans la section **Devices (Appareils)**, choisissez l'appareil.
1. Dans la section **Suites**, choisissez la suite.
1. Dans la section **Tests**, choisissez le test.
1. La section **Video (Vidéo)** affiche un enregistrement vidéo téléchargeable du test.
La section **Résultat** affiche le résultat du test. Le statut est représenté par une icône de résultat. Pour de plus amples informations, veuillez consulter [Statuts d'un test individuel](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
La section **Logs** affiche toutes les informations enregistrées par Device Farm pendant le test. Pour afficher ces informations, suivez les instructions fournies dans [Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport](#how-to-use-reports-console-log).
L'onglet **Fichiers** affiche la liste de tous les fichiers associés au test (tels que les fichiers journaux) que vous pouvez télécharger. Pour télécharger un fichier, cliquez sur le lien du fichier dans la liste.
L'onglet **Captures d'écran** affiche la liste de toutes les captures d'écran capturées par Device Farm pendant le test.
### Afficher les informations du journal relatives à un problème, à un appareil, à une suite ou à un test dans un rapport
La section **Logs** affiche les informations suivantes :
+ **Source** représente la source d'une entrée de journal. Les valeurs possibles incluent :
+ **Harness** représente une entrée de journal créée par Device Farm. Ces entrées de journal sont généralement créées lors du démarrage et de l'arrêt d'événements.
+ Le **périphérique** représente une entrée de journal créée par le périphérique. Pour Android, ces entrées de journal sont compatibles avec logcat. Pour iOS, ces entrées de journal sont compatibles avec syslog.
+ **Test** représente une entrée de journal créée par un test ou son framework de test.
+ **Time (Temps)** représente le temps écoulé entre la première entrée de journal et cette entrée de journal. Le temps est exprimé sous *MM:SS.SSS* forme de *M* minutes et *S* de secondes.
+ **PID** représente l'identifiant de processus (PID) ayant créé l'entrée de journal. Toutes les entrées de journal créées par une application sur un appareil ont le même PID.
+ **Level (Niveau)** représente le niveau de journalisation de l'entrée de journal. Par exemple, `Logger.debug("This is a message!")` consigne un **Level (Niveau)** `Debug`. Voici les valeurs possibles :
+ **Alert (Alerte)**
+ **Critical (Critique)**
+ **Debug (Débogage)**
+ **Emergency (Urgence)**
+ **Error (Erreur)**
+ **Errored (Erroné)**
+ **Échec**
+ **Info (Infos)**
+ **Internal (Interne)**
+ **Notice (Avis)**
+ **Passed (Réussite)**
+ **Ignoré**
+ **Arrêté(e)**
+ **Verbose (Détaillé)**
+ **Warned (Averti)**
+ **Warning (Avertissement)**
+ **Tag (Balise)** représente les métadonnées arbitraires de l'entrée de journal. Par exemple, Android logcat peut s'en servir pour décrire la partie du système ayant créé l'entrée de journal (par exemple, `ActivityManager`).
+ **Message** représente le message ou les données de l'entrée de journal. Par exemple, `Logger.debug("Hello, World!")` journalise le **Message** `"Hello, World!"`.
Pour afficher uniquement une partie des informations :
+ Pour afficher toutes les entrées du journal correspondant à la valeur d'une colonne spécifique, entrez la valeur dans la barre de recherche. Par exemple, pour afficher toutes les entrées du journal dont la valeur **Source** est égale à`Harness`, entrez **Harness** dans la barre de recherche.
+ Pour supprimer tous les caractères d'une zone d'en-tête de colonne, cliquez sur le **X** de cette zone d'en-tête de colonne. Supprimer tous les caractères d'une zone d'en-tête de colonne revient à entrer **\$1** dans cette zone d'en-tête de colonne.
Pour télécharger toutes les informations de journal de l'appareil, y compris toutes les suites et tous les tests que vous avez exécutés, choisissez **Télécharger les journaux**.
# Statuts des résultats des tests Device Farm
La console Device Farm affiche des icônes qui vous aident à évaluer rapidement l'état de votre cycle de test terminé. Pour plus d'informations sur les tests dans Device Farm, consultez[Rapports dans AWS Device FarmRapports](reports.md).
**Topics**
+ [Statuts d'un test individuel](#how-to-use-reports-displaying-results-individual)
+ [Statuts pour plusieurs tests](#how-to-use-reports-displaying-results-summary)
## Statuts d'un test individuel
Pour les rapports décrivant un test individuel, Device Farm affiche une icône représentant l'état des résultats du test :
| Description | Icône |
| --- | --- |
| Le test a abouti. | ![\[The test succeeded.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-success.png) |
| Le test a échoué. | ![\[The test failed.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-failure.png) |
| Device Farm a sauté le test. | ![\[The test was skipped.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-skipped.png) |
| Le test s'est arrêté. | ![\[The test was stopped.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-stopped.png) |
| Device Farm a renvoyé un avertissement. | ![\[Device Farm returned a warning.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-warning.png) |
| Device Farm a renvoyé un message d'erreur. | ![\[Device Farm returned an error.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-run-error.png) |
## Statuts pour plusieurs tests
Si vous choisissez une exécution terminée, Device Farm affiche un graphique récapitulatif indiquant le pourcentage de tests dans différents états.
![\[Device Farm test results summary graph.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/df-summary-results-graph.png)
Par exemple, ce graphique des résultats de test montre que 4 tests ont été interrompus, 1 test ayant échoué et 10 tests réussis.
Les graphiques sont toujours codés par couleur et étiquetés.
# Téléchargement d'artefacts dans Device Farm
Device Farm rassemble des artefacts tels que des rapports, des fichiers journaux et des images pour chaque test en cours d'exécution.
Vous pouvez télécharger les artefacts créés au cours de votre série de tests :
**Fichiers**
Fichiers générés pendant le test, y compris les rapports Device Farm. Pour de plus amples informations, veuillez consulter [Afficher les rapports de test dans Device Farm](how-to-use-reports.md).
**Journaux**
Résultat de chaque test de la série de tests.
**Captures d'écran**
Images d'écran enregistrées pour chaque test de la série de tests.
![\[Workflow diagram showing Project, Run, Job (device), Test suite, and Test stages in AWS Cloud.\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/hierarchy.png)
## Télécharger des artefacts (console)
1. Sur la page des rapports de test, à partir de **Devices (Appareils)**, choisissez un appareil mobile.
1. Pour télécharger un fichier, choisissez-en un dans la liste **Files (Fichiers)**.
1. Pour télécharger les journaux de votre série de tests, à partir de **Logs (Journaux)**, choisissez **Download logs (Télécharger les journaux)**.
1. Pour télécharger une capture d'écran, choisissez-en une à partir de **Screenshots (Captures d'écran)**.
Pour plus d'informations sur le téléchargement d'artefacts dans un environnement de test personnalisé, consultez [Téléchargement d'artefacts dans un environnement de test personnalisé](using-artifacts-custom.md).
## Télécharger des artefacts (AWS CLI)
Vous pouvez utiliser le AWS CLI pour répertorier les artefacts de vos tests.
**Topics**
+ [Étape 1 : Obtenez vos noms de ressources Amazon (ARN)](#artifacts-cli-step1)
+ [Étape 2 : Répertoriez vos artefacts](#artifacts-cli-step2)
+ [Étape 3 : Téléchargez vos artefacts](#artifacts-cli-step3)
### Étape 1 : Obtenez vos noms de ressources Amazon (ARN)
Vous pouvez répertorier vos artefacts par exécution, tâche, série de tests ou test. Vous avez besoin de l'ARN correspondant. Ce tableau indique l'ARN d'entrée pour chacune des commandes de la AWS CLI liste :
| AWS CLI Commande de liste | ARN requis |
| --- | --- |
| list-projects | Cette commande renvoie tous les projets et ne requiert aucun ARN. |
| list-runs | project |
| list-jobs | run |
| list-suites | job |
| list-tests | suite |
Par exemple, pour trouver l'ARN d'un test, exécutez **list-tests** en utilisant l'ARN de votre suite de tests comme paramètre d'entrée.
Exemple :
```
aws devicefarm list-tests –-arn arn:MyTestSuiteARN
```
La réponse inclut l'ARN de chaque test de la série de tests.
```
{
"tests": [
{
"status": "COMPLETED",
"name": "Tests.FixturesTest.testExample",
"created": 1537563725.116,
"deviceMinutes": {
"unmetered": 0.0,
"total": 1.89,
"metered": 1.89
},
"result": "PASSED",
"message": "testExample passed",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:test:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
"counters": {
"skipped": 0,
"warned": 0,
"failed": 0,
"stopped": 0,
"passed": 1,
"errored": 0,
"total": 1
}
}
]
}
```
### Étape 2 : Répertoriez vos artefacts
La commande AWS CLI [list-artefacts](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-artifacts.html) renvoie une liste d'artefacts, tels que des fichiers, des captures d'écran et des journaux. Chaque artefact possède une URL vous permettant de télécharger le fichier.
+ Appelez la commande **list-artifacts** en spécifiant un ARN d'exécution, de tâche, de série de tests ou de test. Spécifiez le type FILE, LOG ou SCREENSHOT.
Cet exemple renvoie une URL de téléchargement pour chaque artefact disponible pour un test :
```
aws devicefarm list-artifacts --arn arn:MyTestARN --type "FILE"
```
La réponse contient une URL de téléchargement pour chaque artefact.
```
{
"artifacts": [
{
"url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
"extension": "txt",
"type": "APPIUM_JAVA_OUTPUT",
"name": "Appium Java Output",
"arn": "arn:aws:devicefarm:us-west-2:123456789101:artifact:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
}
]
}
```
### Étape 3 : Téléchargez vos artefacts
+ Téléchargez votre artefact à l'aide de l'URL de l'étape précédente. Cet exemple utilise **curl** pour télécharger un fichier de sortie Appium Java Android :
```
curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyArtifactName.txt
```
## Télécharger des artefacts (API)
La [ListArtifacts](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)méthode Device Farm API renvoie une liste d'artefacts, tels que des fichiers, des captures d'écran et des journaux. Chaque artefact possède une URL vous permettant de télécharger le fichier.
# Téléchargement d'artefacts dans un environnement de test personnalisé
Dans un environnement de test personnalisé, Device Farm collecte des artefacts tels que des rapports personnalisés, des fichiers journaux et des images. Ces artefacts sont disponibles pour chaque appareil de la série de tests.
Vous pouvez télécharger les artefacts suivants créés au cours de votre série de tests :
**Résultat de spécification de test**
Résultat de l'exécution des commandes du fichier YAML de spécification de test.
**Artefacts client**
Fichier compressé qui contient les artefacts de la série de tests. Il est configuré dans la section **artifacts:** de votre fichier YAML de spécification de test.
**Script shell de spécification de test**
Fichier de script shell intermédiaire créé à partir de votre fichier YAML. Étant donné qu'il est utilisé dans la série de tests, le fichier de script shell peut être utilisé pour déboguer le fichier YAML.
**Fichier de spécification de test**
Fichier YAML utilisé dans la série de tests.
Pour de plus amples informations, veuillez consulter [Téléchargement d'artefacts dans Device Farm](artifacts.md).
![\[Hiérarchie des opérations Device Farm dans un environnement de test personnalisé\]](http://docs.aws.amazon.com/fr_fr/devicefarm/latest/developerguide/images/hierarchy.png)