Création d'un test dans Device Farm

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

2. Dans le volet de navigation, choisissez Mobile Device Testing, puis choisissez Projets.

3. 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.

4. Ouvrez votre projet, puis choisissez Créer une exécution.

5. Sous Sélectionnez l'application et le type 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.

6. 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 dossier de candidature. Si vous chargez une application iOS, veillez à choisir iOS device (Appareil iOS) et non un simulateur.

7. Dans Configurer le test, choisissez l'un des frameworks de test disponibles.

   Note

   Si aucun test n'est disponible, choisissez Built-in : Fuzz pour exécuter une suite de tests standard intégrée. Si vous choisissez Built-in : Fuzz et que les boîtes de départ Event count, Event throttle et Randomizer apparaissent, 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.

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

9. 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.

10. 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 du 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.

11. 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, 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 Farm.

12. (Facultatif) Pour configurer les propriétés au niveau de l'exécution, mettez à jour la section Paramètres d'exécution. Ici, vous pouvez effectuer les opérations suivantes :

    • Attribuez à votre course un nom de course personnalisé. Si aucun nom n'est fourni, la console Device Farm appellera votre exécution « My Device Farm run » par défaut.

    • Choisissez Générer un rapport de test sous Test Insights pour obtenir un rapport de test structuré détaillé pour chaque tâche et un résumé agrégé au niveau de l'exécution. Ces informations sont générées en plus de tout rapport de test que vous pourriez générer dans le cadre de l'exécution de votre test.

    • Attribuez un délai d'expiration à une tâche, qui correspond au nombre maximum de minutes pendant lequel une tâche peut être exécutée sur un appareil. Si vos tests sont terminés avant la fin de la tâche, celle-ci est terminée et vous n'êtes pas facturé pour le reste de la durée de la tâche. La valeur par défaut est de 150 minutes.

    • Choisissez un mode de facturation. Par défaut, si aucune machine à sous n'a été achetée sur votre compte, la console Device Farm sélectionne Metered. Si vous avez des emplacements, la console est réglée par défaut sur Unmetered.

13. (Facultatif) Pour ajouter une configuration supplémentaire, ouvrez la liste déroulante 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é sur le projet parent, utilisez le champ ARN du rôle d'exécution.

    • Pour fournir d'autres données que Device Farm pourra utiliser pendant l'exécution, à côté de Ajouter des données supplémentaires, choisissez Choisir un fichier, puis recherchez et choisissez le fichier .zip qui contient les données.

    • Pour installer une application supplémentaire que Device Farm pourra utiliser pendant l'exécution, à côté de Installer d'autres applications, choisissez Choisir un fichier, 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 Bluetooth Wi-Fi, GPS ou NFC est activé pendant la course, cochez les cases appropriées à côté de Définir les états radio.

    • 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 les tests.

    Note

    Le réglage de l'état radio et des paramètres régionaux de l'appareil sont des options uniquement disponibles pour les tests natifs Android pour le moment.

    Note

    Si vous possédez des appareils privés, la configuration spécifique aux appareils privés est également affichée.

14. Au bas de la page, choisissez Confirmer et lancez l'exécution pour planifier l'exécution.

1. Pour répertorier vos projets Device Farm, exécutezlist-projects. Si vous n'avez aucun projet, consultez Création d'un projet dans AWS Device Farm.

   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
           }
       ]
   }

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

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 d'appareils Device Farm intégrés, tels queTop Devices, et tous les pools d'appareils 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"
           }
       ]
   }

2. 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éez un pool d'appareils (AWS CLI).

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"
       }
   }

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

3. Télé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 d'URL présignées dans le guide de l'utilisateur d'Amazon Simple Storage Service.

4. 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}"
       }
   }

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"
       }    
   }

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

3. Téléchargez le fichier de votre package de 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"

4. 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}"
       }
   }

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"
               }
           }
       ]
   }

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

3. 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.

4. 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

5. 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é.

6. 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"
       }
   }

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

8. 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"

9. 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 update-upload.

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 schedule-run.

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