Creazione di un'esecuzione di test in Device Farm

1. Accedi alla console Device Farm all'indirizzo https://console.aws.amazon.com/devicefarm.

2. Nel pannello di navigazione, scegli Mobile Device Testing, quindi scegli Progetti.

3. Se è già stato creato un progetto, è possibile caricare i test. Altrimenti, scegli Nuovo progetto, inserisci il nome del progetto, quindi scegli Crea.

4. Apri il progetto, quindi scegli Crea ed esegui.

5. In Seleziona app e tipo di esecuzione, nella sezione Tipo di esecuzione, seleziona il tipo di esecuzione. Seleziona l'app per Android se non hai un'app pronta per il test o se stai testando un'app Android (.apk). Seleziona l'app iOS se stai testando un'app iOS (.ipa). Seleziona App Web se desideri testare le applicazioni Web.

6. In Seleziona app, nella sezione delle opzioni di selezione delle app, scegli Seleziona un'app di esempio fornita da Device Farm se non hai un'app disponibile per il test. Se stai portando la tua app, seleziona Carica la tua app e scegli il file della tua applicazione. Se si sta caricando un'app iOS, assicurarsi di selezionare iOS device (dispositivo iOS), invece di un simulatore.

7. In Configura test, scegli uno dei framework di test disponibili.

   Nota

   Se non hai test disponibili, scegli Built-in: Fuzz per eseguire una suite di test standard integrata. Se scegli Built-in: Fuzz e vengono visualizzate le caselle iniziali Event count, Event throttle e Randomizer, puoi modificare o mantenere i valori.

   Per informazioni sulle suite di test disponibili, consulta Framework di test e test integrati in AWS Device Farm.

8. Se non hai scelto Built-in: Fuzz, seleziona Scegli file in Seleziona pacchetto di test. Cerca e scegli il file che contiene i tuoi test.

9. Per il tuo ambiente di test, scegli Esegui il test nel nostro ambiente standard o Esegui il test in un ambiente personalizzato. Per ulteriori informazioni, consulta Ambienti di test in AWS Device Farm.

10. Se utilizzi un ambiente di test personalizzato, puoi facoltativamente fare quanto segue:

    • Se si desidera modificare il file di specifica predefinito in un ambiente di test personalizzato, selezionare Edit (Modifica) per aggiornare la specifica YAML predefinita.

    • Se hai modificato le specifiche di test, scegli Salva come nuovo per aggiornarle.

    • È possibile configurare le variabili di ambiente. Le variabili fornite qui avranno la precedenza su tutte quelle che possono essere configurate nel progetto principale.

11. In Seleziona dispositivi, effettuate una delle seguenti operazioni:

    • Per selezionare un pool di dispositivi integrato per eseguire i test, per Device pool (Pool di dispositivi), selezionare Top Devices (Dispositivi migliori).

    • Per creare il pool di dispositivi per eseguire i test, segui le istruzioni contenute in Creazione di un pool di dispositivi, quindi torna a questa pagina.

    • Se hai creato il pool di dispositivi in precedenza, per Device pool (Pool di dispositivi), selezionare il pool di dispositivi.

    • Seleziona manualmente i dispositivi e scegli i dispositivi desiderati su cui eseguire l'esecuzione. Questa configurazione non verrà salvata.

    Per ulteriori informazioni, consulta Supporto per i dispositivi in AWS Device Farm.

12. (Facoltativo) Per configurare le proprietà a livello di esecuzione, aggiorna la sezione Run Settings. Qui puoi fare quanto segue:

    • Assegna alla corsa un nome di corsa personalizzato. Se non viene fornito alcun nome, per impostazione predefinita la console Device Farm assegnerà all'esecuzione il nome «My Device Farm run».

    • Scegli Genera rapporto di test in Test Insights per ottenere un rapporto di test strutturato dettagliato per ogni job e un riepilogo aggregato a livello di esecuzione. Queste informazioni vengono generate in aggiunta a qualsiasi rapporto di test che potresti generare come parte dell'esecuzione del test.

    • Assegna un timeout del lavoro, che è il numero massimo di minuti in cui un processo può essere eseguito su un dispositivo. Se i test vengono completati prima del timeout del job, il job viene completato e non ti verrà addebitato alcun costo per il resto del timeout. L'impostazione predefinita è 150 minuti.

    • Scegli un metodo di fatturazione. Per impostazione predefinita, se non hai acquistato slot sul tuo account, la console Device Farm seleziona Metered. Se disponi di slot, il valore predefinito della console è Unmetered.

13. (Facoltativo) Per aggiungere una configurazione aggiuntiva, apri il menu a discesa Configurazione aggiuntiva. In questa sezione, puoi effettuare una delle seguenti operazioni:

    • Per fornire un ARN del ruolo di esecuzione o sostituirne uno configurato nel progetto principale, utilizzate il campo ARN del ruolo di esecuzione.

    • Per fornire altri dati da utilizzare per Device Farm durante l'esecuzione, accanto a Aggiungi dati aggiuntivi, scegli Scegli file, quindi cerca e scegli il file .zip che contiene i dati.

    • Per installare un'app aggiuntiva da utilizzare per Device Farm durante l'esecuzione, accanto a Installa altre app, scegli Scegli file, quindi cerca e scegli il file .apk o .ipa che contiene l'app. Ripetere questa operazione per altre applicazioni che si desidera installare. Puoi modificare l'ordine di installazione trascinando le app dopo averle caricate.

    • Per specificare se Bluetooth Wi-Fi, GPS o NFC sono abilitati durante l'esecuzione, accanto a Imposta stati radio, seleziona le caselle appropriate.

    • Per preconfigurare la latitudine e la longitudine del dispositivo per la sessione, accanto a Device location (Posizione dispositivo), immettere le coordinate.

    • Per preimpostare le impostazioni locali del dispositivo per l'esecuzione, in Impostazioni locali del dispositivo, scegli le impostazioni internazionali.

    • Seleziona Abilita registrazione video per registrare video durante il test.

    Nota

    L'impostazione dello stato della radio e delle impostazioni locali del dispositivo sono opzioni disponibili solo per i test nativi di Android in questo momento.

    Nota

    Se disponi di dispositivi privati, viene visualizzata anche la configurazione specifica dei dispositivi privati.

14. Nella parte inferiore della pagina, scegli Conferma e avvia la corsa per pianificare l'esecuzione.

1. Per elencare i tuoi progetti Device Farm, eseguilist-projects. Se non disponi ancora di un progetto, consulta Creazione di un progetto in AWS Device Farm.

   Esempio:

   aws devicefarm list-projects

   La risposta include un elenco dei tuoi progetti Device Farm.

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

2. Scegliere un progetto da associare alla sessione di test e prendere nota del suo Amazon Resource Name (ARN).

1. Per visualizzare i pool di dispositivi, eseguire list-device-pools specificando l'ARN del progetto.

   Esempio:

   aws devicefarm list-device-pools --arn arn:MyProjectARN

   La risposta include i pool di dispositivi Device Farm integrati, ad esempioTop Devices, e tutti i pool di dispositivi creati in precedenza per questo progetto:

   {
       "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. Scegliere un pool di dispositivi e prendere nota del suo ARN.

   È inoltre possibile creare un pool di dispositivi e ritornare a questa fase. Per ulteriori informazioni, consulta Crea un pool di dispositivi (AWS CLI).

1. Per caricare un file, eseguire create-upload con i parametri –-project-arn, --type e --name.

   Questo esempio crea un caricamento per un'applicazione Android:

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

   La risposta include l'ARN di caricamento dell'applicazione e un URL prefirmato.

   {
       "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. Prendere nota dell'ARN di caricamento dell'applicazione e dell'URL prefirmato.

3. Carica il file della tua app utilizzando l'URL prefirmato di Amazon S3. Questo esempio utilizza curl per caricare un file .apk Android:

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

   Per ulteriori informazioni, consulta Caricare oggetti utilizzando URL prefirmati nella Amazon Simple Storage Service User Guide.

4. Per verificare lo stato del caricamento dell'applicazione, eseguire get-upload e specificare l'ARN di caricamento dell'applicazione.

   aws devicefarm get-upload –-arn arn:MyAppUploadARN

   Attendere che lo stato della risposta sia SUCCEEDED prima di caricare il pacchetto degli script di 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. Per creare la tua richiesta di caricamento e ottenere un URL di caricamento prefirmato di Amazon S3, esegui create-upload con i parametri –-project-arn--name, e. --type

   Questo esempio crea un caricamento del pacchetto di test Appium Java TestNG:

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

   La risposta include l'ARN di caricamento del pacchetto di test e un URL prefirmato.

   {
       "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. Prendere nota dell'ARN di caricamento del pacchetto di test e dell'URL prefirmato.

3. Carica il file del pacchetto degli script di test utilizzando l'URL prefirmato di Amazon S3. Questo esempio utilizza curl per caricare un file .zip degli script Appium TestNG.

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

4. Per verificare lo stato del caricamento del pacchetto degli script di test, eseguire get-upload e specificare l'ARN di caricamento del pacchetto di test dalla fase 1.

   aws devicefarm get-upload –-arn arn:MyTestsUploadARN

   Attendere che lo stato della risposta sia SUCCEEDED prima di procedere alla fase successiva facoltativa.

   {
       "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. Per trovare l'ARN di caricamento per la specifica di test predefinita, eseguire list-uploads e specificare l'ARN del progetto.

   aws devicefarm list-uploads --arn arn:MyProjectARN

   La risposta contiene una voce per ciascuna specifica di test predefinita:

   {
       "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. Scegliere la specifica di test predefinita dall'elenco. Prendere nota del suo ARN di caricamento.

3. Per scaricare la specifica di test predefinita, eseguire get-upload e specificare l'ARN di caricamento.

   Esempio:

   aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN

   La risposta contiene un URL prefirmato dove è possibile scaricare la specifica di test predefinita.

4. Questo esempio utilizza curl per scaricare la specifica di test predefinita e salvarla come MyTestSpec.yml:

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

5. Puoi modificare la specifica di test predefinita per soddisfare i requisiti di test e utilizzare la specifica di test modificata in sessioni di test future. Saltare questa fase per utilizzare la specifica di test predefinita così come avviene in un ambiente di test personalizzato.

6. Per creare un caricamento della specifica di test personalizzata, eseguire create-upload specificando il nome della specifica di test, il tipo della specifica di test e l'ARN di progetto.

   Questo esempio crea un caricamento per una specifica di test personalizzata Appium Java TestNG:

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

   La risposta include l'ARN di caricamento della specifica di test e un URL prefirmato:

   {
       "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. Prendere nota dell'ARN per il caricamento della specifica di test e dell'URL prefirmato.

8. Carica il file delle specifiche di test utilizzando l'URL prefirmato di Amazon S3. Questo esempio utilizza curl per caricare una specifica di test di JavaTest Appium NG:

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

9. Per verificare lo stato del caricamento della specifica di test, eseguire get-upload e specificare l'ARN di caricamento.

   aws devicefarm get-upload –-arn arn:MyTestSpecUploadARN

   Attendere che lo stato della risposta sia SUCCEEDED prima di pianificare la sessione di 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}"
       }
   }

   Per aggiornare la specifica di test personalizzata, eseguire update-upload specificando l'ARN di caricamento per la specifica di test. Per ulteriori informazioni, consulta update-upload.

Per pianificare una sessione in un ambiente di test standard

• Eseguire schedule-run specificando l'ARN di progetto, l'ARN del pool di dispositivi, l'ARN di caricamento dell'applicazione e le informazioni del pacchetto di test.

  Esempio:

  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 risposta contiene un ARN di sessione che puoi utilizzare per verificare lo stato della sessione di 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
          }
      }
  }

  Per ulteriori informazioni, consulta schedule-run.

Per pianificare una sessione in un ambiente di test personalizzato

• Le fasi sono quasi uguali a quelle per l'ambiente di test standard con un attributo aggiuntivo testSpecArn nel parametro --test.

  Esempio:

  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

Per verificare lo stato della sessione di test

• Utilizzare il comando get-run e specificare l'ARN di sessione:

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