Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# I test vengono eseguiti in AWS Device Farm
Un'esecuzione in Device Farm rappresenta una build specifica dell'app, con una serie specifica di test, da eseguire su un set specifico di dispositivi. Un'esecuzione produce un rapporto che contiene informazioni sui risultati dell'esecuzione. Un'esecuzione contiene uno o più processi. Per ulteriori informazioni, consulta [Esecuzioni](test-runs.md).
Puoi utilizzare la console AWS Device Farm, AWS Command Line Interface (AWS CLI) o l'API AWS Device Farm per lavorare con le esecuzioni di test.
**Topics**
+ [Creazione di un'esecuzione di test in Device Farm](how-to-create-test-run.md)
+ [Impostazione del timeout di esecuzione per le esecuzioni di test in AWS Device Farm](how-to-set-default-timeout-for-test-runs.md)
+ [Simulazione delle connessioni e delle condizioni di rete per le esecuzioni di AWS Device Farm](how-to-simulate-network-connections-and-conditions.md)
+ [Interruzione di un'esecuzione in AWS Device Farm](how-to-stop-test-runs.md)
+ [Visualizzazione di un elenco di esecuzioni in AWS Device Farm](how-to-view-runs-list.md)
+ [Creazione di un pool di dispositivi in AWS Device Farm](how-to-create-device-pool.md)
+ [Analisi dei risultati dei test in AWS Device Farm](analyzing-results.md)
# Creazione di un'esecuzione di test in Device Farm
Puoi utilizzare la console Device Farm o AWS CLI l'API Device Farm per creare un'esecuzione di test. Puoi anche utilizzare un plug-in supportato, come i plugin Jenkins o Gradle per Device Farm. Per ulteriori informazioni sui plugin , consulta [Strumenti e plugin](aws-device-farm-tools-plugins.md). Per informazioni sulle sessioni, consulta [Esecuzioni](test-runs.md).
**Topics**
+ [Prerequisiti](#how-to-create-test-run-prerequisites)
+ [Crea un'esecuzione di test (console)](#how-to-create-test-run-console)
+ [Crea un test run (AWS CLI)](#how-to-create-test-run-cli)
+ [Creare un test run (API)](#how-to-create-test-run-api)
+ [Fasi successive](#how-to-create-test-run-console-next-steps)
## Prerequisiti
È necessario disporre di un progetto in Device Farm. Segui le istruzioni riportate in [Creazione di un progetto in AWS Device Farm](how-to-create-project.md), poi torna a questa pagina.
## Crea un'esecuzione di test (console)
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. **Nel riquadro di navigazione, scegli **Mobile Device Testing, quindi** scegli Progetti.**
1. Se è già stato creato un progetto, è possibile caricare i test. Altrimenti, scegliete **Nuovo progetto**, inserite un **nome di progetto**, quindi scegliete **Crea**.
1. Apri il progetto, quindi scegli **Crea esegui**.
1. (Facoltativo) In **Impostazioni** di **esecuzione, nella sezione Nome esecuzione**, inserisci un nome per la corsa. Se non viene fornito alcun nome, la console Device Farm chiamerà l'esecuzione «My Device Farm run» per impostazione predefinita.
1. (Facoltativo) In **Impostazioni di esecuzione**, nella sezione **Job timeout**, puoi specificare il timeout di esecuzione per l'esecuzione del test. **Se utilizzi slot di test illimitati, conferma che **Unmetered** sia selezionato in Metodo di fatturazione.**
1. In **Impostazioni di corsa**, nella sezione **Tipo di corsa, seleziona il tipo** di corsa. Seleziona **l'app per Android** se non hai un'app pronta per il test o se stai testando un'app per Android (.apk). Seleziona **App iOS** se stai testando un'app iOS (.ipa). Seleziona **App Web** se desideri testare le applicazioni Web.
1. In **Seleziona app**, nella sezione **Opzioni di selezione app**, scegli **Seleziona app di esempio fornita da Device Farm** se non hai un'app disponibile per il test. Se porti la tua app, seleziona **Carica la tua app** e scegli il file dell'applicazione. Se si sta caricando un'app iOS, assicurarsi di selezionare **iOS device (dispositivo iOS)**, invece di un simulatore.
1. In **Configure test**, scegli uno dei framework di test disponibili.
**Nota**
Se non si dispone di alcun test disponibile, selezionare **Built-in: Fuzz (Integrata: Fuzz)** per eseguire una suite di test integrata standard. Se si sceglie **Built-in: Fuzz (Integrata: Fuzz)** e vengono visualizzate le caselle **Event count (Conteggio eventi)**, **Event throttle (Limite eventi)** e **Randomizer seed (Seed randomizer)**, è possibile modificare o mantenere i valori.
Per informazioni sulle suite di test disponibili, consulta [Framework di test e test integrati in AWS Device Farm](test-types.md).
1. 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.
1. 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](test-environments.md).
1. 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 del test, scegli **Salva come nuovo** per aggiornarle.
+ È possibile configurare le variabili di ambiente. Le variabili fornite qui avranno la precedenza su quelle che possono essere configurate nel progetto principale.
1. 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](how-to-create-device-pool.md), 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 **Seleziona manualmente i dispositivi** e scegli i dispositivi desiderati su cui vuoi correre. Questa configurazione non verrà salvata.
Per ulteriori informazioni, consulta [Supporto per dispositivi in AWS Device Farmdispositivi](devices.md).
1. (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 ruolo di esecuzione ARN o sovrascrivere uno configurato nel progetto principale, utilizzare il campo ARN del ruolo di esecuzione.
+ Per fornire altri dati da utilizzare a 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 in 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 una rete Wi-Fi, Bluetooth, GPS o NFC sia abilitata durante la sessione, accanto a **Set radio states (Imposta stati radio)**, selezionare 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 locali**.
+ Seleziona **Abilita la registrazione video** per registrare video durante il test.
+ Seleziona **Abilita l'acquisizione dei dati sulle prestazioni dell'app** per acquisire i dati sulle prestazioni dal dispositivo.
**Nota**
L'impostazione dello stato radio e delle impostazioni locali del dispositivo sono opzioni disponibili solo per i test nativi Android al momento.
**Nota**
Se disponi di dispositivi privati, viene visualizzata anche la configurazione specifica per i dispositivi privati.
1. Nella parte inferiore della pagina, scegli **Crea corsa** per pianificare la corsa.
Device Farm avvia l'esecuzione non appena i dispositivi sono disponibili, in genere entro pochi minuti. Durante l'esecuzione del test, la console Device Farm visualizza un'icona ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-calendar.png) in sospeso nella tabella di esecuzione. Ogni dispositivo in esecuzione inizierà anche con l'icona in sospeso, quindi passerà all'icona ![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-progress.png) in esecuzione all'inizio del test. Al termine di ogni test, accanto al nome del dispositivo viene visualizzata l'icona del risultato del test. Una volta completati tutti i test, l'icona in sospeso accanto all'esecuzione diventa l'icona del risultato del test.
Se desideri interrompere l'esecuzione del test, consulta[Interruzione di un'esecuzione in AWS Device Farm](how-to-stop-test-runs.md).
## Crea un test run (AWS CLI)
È possibile utilizzare il AWS CLI per creare un'esecuzione di test.
**Topics**
+ [Fase 1: Scegli un progetto](#how-to-create-test-run-cli-step1)
+ [Passaggio 2: Scegli un pool di dispositivi](#how-to-create-test-run-cli-step2)
+ [Passaggio 3: carica il file della tua candidatura](#how-to-create-test-run-cli-step3)
+ [Passaggio 4: carica il pacchetto di script di test](#how-to-create-test-run-cli-step4)
+ [Fase 5: (Facoltativo) Carica le specifiche di test personalizzate](#how-to-create-test-run-cli-step5)
+ [Passaggio 6: Pianifica un'esecuzione di test](#how-to-create-test-run-cli-step6)
### Fase 1: Scegli un progetto
È necessario associare l'esecuzione del test a un progetto Device Farm.
1. Per elencare i tuoi progetti Device Farm, esegui**list-projects**. Se non disponi ancora di un progetto, consulta [Creazione di un progetto in AWS Device Farm](how-to-create-project.md).
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
}
]
}
```
1. Scegliere un progetto da associare alla sessione di test e prendere nota del suo Amazon Resource Name (ARN).
### Passaggio 2: Scegli un pool di dispositivi
È necessario selezionare un pool di dispositivi da associare alla sessione di test.
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 esempio**Top 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"
}
]
}
```
1. 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](how-to-create-device-pool.md#how-to-create-device-pool-cli).
### Passaggio 3: carica il file della tua candidatura
Per creare la tua richiesta di caricamento e ottenere un URL di caricamento predefinito di Amazon Simple Storage Service (Amazon S3), devi:
+ L'ARN di progetto.
+ Il nome del file di applicazione.
+ Il tipo di caricamento.
Per ulteriori informazioni, consulta [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. 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"
}
}
```
1. Prendere nota dell'ARN di caricamento dell'applicazione e dell'URL prefirmato.
1. Carica il file dell'app utilizzando l'URL predefinito 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 [Caricamento di oggetti utilizzando presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) nella Guida per l'*utente di Amazon Simple Storage Service*.
1. 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}"
}
}
```
### Passaggio 4: carica il pacchetto di script di test
Quindi, caricare il pacchetto degli script di test.
1. Per creare la tua richiesta di caricamento e ottenere un URL di caricamento predefinito per Amazon S3, esegui **create-upload** con i parametri `–-project-arn``--name`, and. `--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"
}
}
```
1. Prendere nota dell'ARN di caricamento del pacchetto di test e dell'URL prefirmato.
1. Carica il file del pacchetto degli script di test utilizzando l'URL predefinito 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"
```
1. 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}"
}
}
```
### Fase 5: (Facoltativo) Carica le specifiche di test personalizzate
Se si eseguono i test in un ambiente di test standard, saltare questa fase.
Device Farm mantiene un file delle specifiche di test predefinito per ogni tipo di test supportato. Quindi, scaricare la specifica di test predefinita e utilizzarla per creare un caricamento della specifica personalizzata per l'esecuzione dei test in un ambiente di test personalizzato. Per ulteriori informazioni, consulta [Ambienti di test in AWS Device Farm](test-environments.md).
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"
}
}
]
}
```
1. Scegliere la specifica di test predefinita dall'elenco. Prendere nota del suo ARN di caricamento.
1. 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.
1. 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
```
1. 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.
1. 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"
}
}
```
1. Prendere nota dell'ARN per il caricamento della specifica di test e dell'URL prefirmato.
1. Carica il file delle specifiche di test utilizzando l'URL predefinito di Amazon S3. Questo esempio utilizza **curl** per caricare una specifica di test JavaTest Appium NG:
```
curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
```
1. 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 [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html).
### Passaggio 6: Pianifica un'esecuzione di test
Per pianificare un'esecuzione di test con AWS CLI, esegui**schedule-run**, specificando:
+ L'ARN del progetto dalla [fase 1](#how-to-create-test-run-cli-step1).
+ L'ARN del pool dei dispositivi dalla [fase 2](#how-to-create-test-run-cli-step2).
+ L'ARN di caricamento dell'applicazione dalla [fase 3](#how-to-create-test-run-cli-step3).
+ L'ARN di caricamento del pacchetto di test dalla [fase 4](#how-to-create-test-run-cli-step4).
Se si eseguono i test in un ambiente di test personalizzato, è necessario anche l'ARN della specifica di test dalla [fase 5](#how-to-create-test-run-cli-step5).
**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 [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html).
**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
```
Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html). Per informazioni sull'utilizzo di Device Farm con AWS CLI, vedere[AWS CLI riferimento](cli-ref.md).
## Creare un test run (API)
I passaggi sono gli stessi descritti nella AWS CLI sezione. Per informazioni, consulta [Crea un test run (AWS CLI)](#how-to-create-test-run-cli).
Queste informazioni sono necessarie per chiamare l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html):
+ Un ARN di progetto. Consulta [Crea un progetto (API)](how-to-create-project.md#how-to-create-project-api) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html).
+ Un ARN di caricamento dell'applicazione. Per informazioni, consulta [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Un ARN di caricamento del pacchetto di test. Per informazioni, consulta [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Un ARN del pool di dispositivi. Consulta [Creazione di un pool di dispositivi](how-to-create-device-pool.md) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).
**Nota**
Se si eseguono i test in un ambiente di test personalizzato, è necessario anche l'ARN di caricamento della specifica di test. Per ulteriori informazioni, consultare [Fase 5: (Facoltativo) Carica le specifiche di test personalizzate](#how-to-create-test-run-cli-step5) e [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
Per informazioni sull'utilizzo dell'API Device Farm, vedere[Automazione di Device Farm](api-ref.md).
## Fasi successive
Nella console Device Farm, l'icona dell'orologio ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-calendar.png) diventa un'icona del risultato, ad esempio successo al ![\[The test succeeded.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-success.png) termine dell'esecuzione. Al termine dei test, viene visualizzato un rapporto per la sessione. Per ulteriori informazioni, consulta [Report in AWS Device FarmReport](reports.md).
Per utilizzare il rapporto, segui le istruzioni riportate in [Visualizzazione dei report dei test in Device Farm](how-to-use-reports.md).
# Impostazione del timeout di esecuzione per le esecuzioni di test in AWS Device Farm
È possibile impostare un valore per la durata della sessione di un test prima di arrestare l'esecuzione del test su ogni dispositivo. Il timeout di esecuzione predefinito è di 150 minuti per dispositivo, ma è possibile impostare un valore minimo di 5 minuti. Puoi utilizzare la console AWS Device Farm o l'API AWS Device Farm per impostare il timeout di esecuzione. AWS CLI
**Importante**
Il timeout di esecuzione deve essere impostato per la *durata massima* di una sessione di test, insieme ad alcuni buffer. Ad esempio, se i tuoi test durano 20 minuti per dispositivo, è opportuno scegliere un timeout di 30 minuti per dispositivo.
Se l'esecuzione supera il timeout, l'esecuzione su quel dispositivo è arrestata forzatamente. Sono disponibili i risultati parziali, laddove possibile. Se si utilizza l'opzione di fatturazione con misurazione, l'esecuzione è fatturata fino a quel punto. Per ulteriori informazioni sui prezzi, consulta la pagina dei [prezzi di Device Farm](https://aws.amazon.com/device-farm/pricing/).
È possibile utilizzare questa funzione se si conosce la possibile durata di una sessione di test su ciascun dispositivo. Quando si specifica un timeout di esecuzione per una sessione di test, è possibile evitare che una sessione di test sia bloccata per qualsiasi motivo e che vengano fatturati minuti in cui i test non erano in esecuzione sul dispositivo. In altre parole, utilizzando la funzione del timeout di esecuzione è possibile arrestare una sessione nel caso in cui stia durando più del previsto.
È possibile impostare il timeout di esecuzione in due modi: a livello del progetto e a livello della sessione di test.
## Prerequisiti
1. Completa le fasi descritte in [Configurazione](setting-up.md).
1. Crea un progetto in Device Farm. Segui le istruzioni riportate in [Creazione di un progetto in AWS Device Farm](how-to-create-project.md), poi torna a questa pagina.
## Imposta il timeout di esecuzione per un progetto
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. Nel pannello di navigazione di Device Farm, scegli **Mobile Device Testing**, quindi scegli **Progetti**.
1. Se hai già un progetto, selezionalo dall'elenco. Altrimenti, scegli **Nuovo progetto**, inserisci un nome per il progetto, quindi scegli **Invia**.
1. Selezionare **Project settings (Impostazioni del progetto)**.
1. Nella scheda **General (Generale)** per **Execution timeout (Timeout di esecuzione)**, immettere un valore oppure utilizzare la barra di scorrimento.
1. Scegli **Save** (Salva).
Ora tutte le sessioni di test nel proprio progetto utilizzano il valore del timeout di esecuzione, a meno che non si sovrascriva il valore del timeout quando si pianifica una sessione.
## Imposta il timeout di esecuzione per un'esecuzione di test
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. Nel pannello di navigazione di Device Farm, scegli **Mobile Device Testing**, quindi scegli **Progetti**.
1. Se hai già un progetto, selezionalo dall'elenco. Altrimenti, scegli **Nuovo progetto**, inserisci un nome per il progetto, quindi scegli **Invia**.
1. Scegliere **Create a new run (Crea una nuova sessione)**.
1. Seguire la procedura per scegliere un'applicazione, configurare il test, selezionare i propri dispositivi e specificare lo stato dei dispositivi.
1. In **Review and start run**, per **Imposta il timeout di esecuzione**, inserisci un valore o usa la barra di scorrimento.
1. Selezionare **Confirm and start run (Controlla e avvia sessione)**.
# Simulazione delle connessioni e delle condizioni di rete per le esecuzioni di AWS Device Farm
Puoi utilizzare il network shaping per simulare le connessioni e le condizioni di rete durante il test delle tue app Android, iOS e web in Device Farm. Ad esempio, puoi simulare una connettività Internet con perdite o intermittente.
Quando si crea una sessione utilizzando le impostazioni di rete predefinite, ogni dispositivo dispone di una connessione Wi-Fi completa e gratuita con connettività Internet. Quando si utilizza il network shaping, è possibile modificare la connessione Wi-Fi per specificare un profilo di rete come **3G** o **Lossy WiFi che controlli la velocità effettiva, il ritardo, il jitter e la perdita** per il traffico in entrata e in uscita.
**Topics**
+ [Imposta la configurazione della rete quando pianifichi un'esecuzione di test](#network-shaping-how-to-choose-a-curated-profile-when-scheduling-a-test-run)
+ [Crea un profilo di rete](#network-shaping-how-to-create-a-network-profile)
+ [Modifica le condizioni della rete durante il test](#change-network-conditions-during-test)
## Imposta la configurazione della rete quando pianifichi un'esecuzione di test
Quando pianifichi una corsa, puoi scegliere uno qualsiasi dei profili curati da Device Farm oppure puoi crearne e gestirne uno tuo.
1. Da qualsiasi progetto Device Farm, scegli **Crea una nuova esecuzione**.
Se non hai ancora un progetto, consulta [Creazione di un progetto in AWS Device Farm](how-to-create-project.md).
1. Scegli l'applicazione, quindi scegli **Avanti**.
1. Configura il test, quindi scegli **Avanti**.
1. Seleziona i tuoi dispositivi, quindi scegli **Avanti**.
1. Nella sezione **Impostazioni di posizione e rete**, scegli un profilo di rete o scegli **Crea profilo di rete** per crearne uno personalizzato.
![\[Profilo di rete per una sessione di test\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-set-up-network-profile.png)
1. Scegli **Next (Successivo)**.
1. Verifica e avvio della sessione di test.
## Crea un profilo di rete
Quando si crea una sessione di test, è possibile creare un profilo di rete.
1. Scegli **Crea profilo di rete**.
![\[Creazione di un nuovo profilo di rete\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-create-a-new-network-profile.png)
1. Immettere un nome e le impostazioni per il proprio profilo di rete.
1. Scegli **Create** (Crea).
1. Termina di creare la tua sessione di test e avvia l'esecuzione.
Dopo aver creato un profilo di rete, potrai visualizzarlo e gestirlo nella pagina **Project settings (Impostazioni del progetto)**.
![\[Profili di rete nelle impostazioni del progetto\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-network-profiles-in-project-settings.png)
## Modifica le condizioni della rete durante il test
Puoi chiamare un'API dall'host del tuo dispositivo utilizzando un framework come Appium per simulare condizioni di rete dinamiche come una larghezza di banda ridotta durante l'esecuzione del test. Per ulteriori informazioni, consulta [CreateNetworkProfile](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateNetworkProfile.html).
# Interruzione di un'esecuzione in AWS Device Farm
È possibile arrestare una sessione dopo averla avviata. Ad esempio, se noti un problema mentre i tuoi test sono in esecuzione è possibile riavviare la sessione con uno script di prova aggiornato.
Puoi utilizzare la console o l'API Device Farm per interrompere un'esecuzione. AWS CLI
**Topics**
+ [Interrompi una corsa (console)](#how-to-stop-run-console)
+ [Interrompi una corsa ()AWS CLI](#how-to-stop-test-run-cli)
+ [Interrompere un'esecuzione (API)](#how-to-stop-test-run-api)
## Interrompi una corsa (console)
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. Nel pannello di navigazione di Device Farm, scegli **Mobile Device Testing**, quindi scegli **Progetti**.
1. Scegliete il progetto in cui avete un test attivo.
1. Nella pagina **Test automatici**, scegli l'esecuzione del test.
L'icona in sospeso o in esecuzione dovrebbe apparire a sinistra del nome del dispositivo.
![\[Device Farm: arrestare una sessione di test\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-stop-run.png)
1. Selezionare **Stop run (Arresta sessione)**.
Dopo poco tempo, accanto al nome del dispositivo viene visualizzata un'icona con un cerchio rosso con un segno meno all'interno. Quando la corsa viene interrotta, il colore dell'icona cambia da rosso a nero.
**Importante**
Se un test è già stato eseguito, Device Farm non può fermarlo. Se è in corso un test, Device Farm lo interrompe. Il totale dei minuti che saranno fatturati appare nella sezione **Devices (Dispositivi)**. Inoltre, ti verranno fatturati anche i minuti totali che Device Farm impiega per eseguire la suite di installazione e la suite di smontaggio. Per ulteriori informazioni, consulta [Prezzi di Device Farm](https://aws.amazon.com/device-farm/faq/#pricing).
L'immagine seguente mostra un esempio della sezione **Dispositivi** dopo che una sessione di test è stata correttamente arrestata.
![\[Device Farm - Pagina dei dettagli di una sessione arrestata\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/aws-device-farm-stop-run-view-details.png)
## Interrompi una corsa ()AWS CLI
Puoi eseguire il comando seguente per interrompere l'esecuzione del test specificata, dove si *myARN* trova l'Amazon Resource Name (ARN) dell'esecuzione del test.
```
$ aws devicefarm stop-run --arn myARN
```
Verrà visualizzato un output simile al seguente:
```
{
"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
}
}
}
```
Per ottenere l'ARN della tua sessione, esegui il comando `list-runs`. L’output visualizzato dovrebbe essere simile al seguente:
```
{
"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
}
}
]
}
```
Per informazioni sull'utilizzo di Device Farm con AWS CLI, vedere[AWS CLI riferimento](cli-ref.md).
## Interrompere un'esecuzione (API)
+ Richiama l'[StopRun](../../latest/APIReference/API_StopRun.html)operazione per l'esecuzione del test.
Per informazioni sull'utilizzo dell'API Device Farm, vedere[Automazione di Device Farm](api-ref.md).
# Visualizzazione di un elenco di esecuzioni in AWS Device Farm
È possibile utilizzare la console o l'API Device Farm per visualizzare un elenco di esecuzioni per un progetto. AWS CLI
**Topics**
+ [Visualizza un elenco di esecuzioni (console)](#how-to-view-runs-list-console)
+ [Visualizza un elenco di esecuzioni (AWS CLI)](#how-to-view-runs-list-cli)
+ [Visualizzare un elenco di esecuzioni (API)](#how-to-view-runs-list-api)
## Visualizza un elenco di esecuzioni (console)
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. Nel pannello di navigazione di Device Farm, scegli **Mobile Device Testing**, quindi scegli **Progetti**.
1. Nell'elenco dei progetti, seleziona il progetto che corrisponde all'elenco che desideri visualizzare.
**Suggerimento**
Puoi utilizzare la barra di ricerca per filtrare l'elenco dei progetti per nome.
## Visualizza un elenco di esecuzioni (AWS CLI)
+ Esegui il comando [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-runs.html).
Per visualizzare informazioni su una singola esecuzione, esegui il comando [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html).
Per informazioni sull'utilizzo di Device Farm con AWS CLI, vedere[AWS CLI riferimento](cli-ref.md).
## Visualizzare un elenco di esecuzioni (API)
+ Chiamata dell'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListRuns.html).
Per visualizzare informazioni su una singola esecuzione, chiama l'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_GetRun.html).
Per informazioni sull'API Device Farm, vedere[Automazione di Device Farm](api-ref.md).
# Creazione di un pool di dispositivi in AWS Device Farm
È possibile utilizzare la console o l'API Device Farm per creare un pool di dispositivi. AWS CLI
**Topics**
+ [Prerequisiti](#how-to-create-device-pool-prerequisites)
+ [Crea un pool di dispositivi (console)](#how-to-create-device-pool-console)
+ [Crea un pool di dispositivi ()AWS CLI](#how-to-create-device-pool-cli)
+ [Creare un pool di dispositivi (API)](#how-to-create-device-pool-api)
## Prerequisiti
+ Crea una corsa nella console Device Farm. Segui le istruzioni in [Creazione di un'esecuzione di test in Device Farm](how-to-create-test-run.md). Una volta alla pagina **Select devices (Seleziona dispositivi)**, continuare con le istruzioni in questa sezione.
## Crea un pool di dispositivi (console)
1. Nella pagina **Progetti**, scegli il tuo progetto. Nella pagina dei **dettagli del progetto**, scegli **Impostazioni del progetto**. Nella scheda **Device pool**, scegli **Crea pool di dispositivi**.
1. Per **Name (Nome)**, immettere un nome che renda semplice identificare il pool di dispositivi.
1. Per **Description (Descrizione)**, immettere una descrizione che renda semplice identificare il pool di dispositivi.
1. Se si desidera utilizzare uno o più criteri di selezione per i dispositivi in questo pool di dispositivi, eseguire quando segue:
1. Scegli **Crea pool dinamico di dispositivi**.
1. Scegli **Aggiungi una regola**.
1. Per **Campo** (primo elenco a discesa), scegli una delle seguenti opzioni:
+ Per includere i dispositivi in base al nome del produttore, scegli Produttore **del dispositivo**.
+ Per includere i dispositivi in base al fattore di forma (tablet o telefono), scegli **Fattore di forma**.
+ Per includere i dispositivi in base al loro stato di disponibilità in base al carico, scegli **Disponibilità**.
+ Per includere solo dispositivi pubblici o privati, scegli **Fleet Type**.
+ Per includere i dispositivi in base al loro sistema operativo, scegli **Piattaforma**.
+ Alcuni dispositivi hanno un'etichetta o una descrizione aggiuntiva sul dispositivo. Puoi trovare i dispositivi in base al contenuto delle etichette selezionando **le etichette delle istanze**.
+ Per includere i dispositivi in base alla versione del sistema operativo, scegli **Versione del sistema operativo**.
+ Per includere i dispositivi in base al modello, scegli **Modello**.
1. Per **Operatore** (secondo elenco a discesa), scegliete un'operazione logica (EQUALS, CONTAINS, ecc.) per includere i dispositivi in base alla query. Ad esempio, puoi scegliere di includere *Availability EQUALS AVAILABLE* i dispositivi che attualmente hanno lo stato. `Available`
1. In **Valore** (terzo elenco a discesa), inserisci o scegli il valore che desideri specificare per i valori **Campo** e **Operatore**. I valori sono limitati in base alla scelta del **campo**. Ad esempio, se scegli **Platform** for **Field**, le uniche selezioni disponibili sono **ANDROID** e **IOS**. **Allo stesso modo, se scegli **Form Factor** for **Field**, le uniche selezioni disponibili sono **TELEFONO e TABLET**.**
1. Per aggiungere un'altra regola, scegli **Aggiungi una regola**.
Dopo aver creato la prima regola, nell'elenco dei dispositivi, la casella accanto a ciascun dispositivo che corrisponde alla regola viene selezionata. Dopo aver creato o modificato le regole, nell'elenco dei dispositivi, la casella accanto a ciascun dispositivo che corrisponde a quelle regole combinate viene selezionata. I dispositivi con caselle selezionate sono inclusi nel pool di dispositivi. I dispositivi con caselle non selezionate vengono esclusi.
1. In Numero **massimo di dispositivi**, inserisci il numero di dispositivi che desideri utilizzare nel tuo pool di dispositivi. Se non inserisci il numero massimo di dispositivi, Device Farm sceglierà tutti i dispositivi del parco dispositivi che corrispondono alle regole che hai creato. Per evitare costi aggiuntivi, imposta questo numero su un importo che corrisponda ai tuoi requisiti effettivi di esecuzione parallela e varietà di dispositivi.
1. Per eliminare una regola, scegli **Rimuovi regola**.
1. Se desideri includere o escludere manualmente singoli dispositivi, procedi come segue:
1. Scegli **Crea pool di dispositivi statici**.
1. Seleziona o deseleziona la casella accanto a ciascun dispositivo. È possibile selezionare o deselezionare le caselle solo se non si dispone di tutte le regole specificate.
1. Se si desidera includere o escludere tutti i dispositivi visualizzati, selezionare o deselezionare la casella nella riga di intestazione della colonna dell'elenco. Se desideri visualizzare solo le istanze private del dispositivo, scegli **Visualizza solo le istanze private del dispositivo**.
**Importante**
Anche se è possibile utilizzare le caselle nella riga dell'intestazione della colonna per modificare l'elenco dei dispositivi visualizzati, non significa che i dispositivi visualizzati rimanenti siano gli unici inclusi o esclusi. Per confermare quali dispositivi sono inclusi o esclusi, assicurarsi di deselezionare i contenuti di tutte le caselle nella riga di intestazione della colonna, quindi esplorare le caselle.
1. Scegli **Create** (Crea).
## Crea un pool di dispositivi ()AWS CLI
**Suggerimento**
Se non inserisci il numero massimo di dispositivi, Device Farm sceglierà tutti i dispositivi del parco dispositivi che corrispondono alle regole che hai creato. Per evitare costi aggiuntivi, imposta questo numero su un importo che corrisponda ai tuoi requisiti effettivi di esecuzione parallela e varietà di dispositivi.
+ Esegui il comando [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).
Per informazioni sull'utilizzo di Device Farm con AWS CLI, vedere[AWS CLI riferimento](cli-ref.md).
## Creare un pool di dispositivi (API)
**Suggerimento**
Se non inserisci il numero massimo di dispositivi, Device Farm sceglierà tutti i dispositivi del parco dispositivi che corrispondono alle regole che hai creato. Per evitare costi aggiuntivi, imposta questo numero su un importo che corrisponda ai tuoi requisiti effettivi di esecuzione parallela e varietà di dispositivi.
+ Chiamata dell'API [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).
Per informazioni sull'utilizzo dell'API Device Farm, vedere[Automazione di Device Farm](api-ref.md).
# Analisi dei risultati dei test in AWS Device Farm
Nell'ambiente di test standard, è possibile utilizzare la console Device Farm per visualizzare i report di ogni test durante l'esecuzione del test. La visualizzazione dei report ti aiuta a capire quali test sono stati superati o meno e ti fornisce dettagli sulle prestazioni e sul comportamento dell'app in diverse configurazioni di dispositivi.
Device Farm raccoglie anche altri elementi come file, log e immagini che è possibile scaricare al termine del test. Queste informazioni possono aiutarti ad analizzare il comportamento dell'app su dispositivi reali, a identificare problemi o bug e a diagnosticare i problemi.
**Topics**
+ [Visualizzazione dei report dei test in Device Farm](how-to-use-reports.md)
+ [Scaricamento di artefatti in Device Farm](artifacts.md)
# Visualizzazione dei report dei test in Device Farm
Usa la console Device Farm per visualizzare i report dei test. Per ulteriori informazioni, consulta [Report in AWS Device FarmReport](reports.md).
**Topics**
+ [Prerequisiti](#how-to-use-reports-prerequisites)
+ [Visualizza i report](#how-to-use-reports-viewing-reports)
+ [Stati dei risultati del test Device Farm](how-to-use-reports-displaying-results.md)
## Prerequisiti
Configura un'esecuzione di un test e verifica che sia completa.
1. Per creare un'esecuzione, consulta [Creazione di un'esecuzione di test in Device Farm](how-to-create-test-run.md) e torna a questa pagina.
1. Verifica che l'esecuzione sia completa. Durante l'esecuzione del test, la console Device Farm visualizza un'icona in sospeso ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-calendar.png) per le esecuzioni in corso. Ogni dispositivo in esecuzione inizierà anche con l'icona in sospeso, quindi passerà all'![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-progress.png)icona in esecuzione all'inizio del test. Al termine di ogni test, accanto al nome del dispositivo viene visualizzata l'icona del risultato del test. Una volta completati tutti i test, l'icona in sospeso accanto all'esecuzione diventa l'icona del risultato del test. Per ulteriori informazioni, consulta [Stati dei risultati del test Device Farm](how-to-use-reports-displaying-results.md).
## Visualizza i report
È possibile visualizzare i risultati del test nella console Device Farm.
**Topics**
+ [Visualizza la pagina di riepilogo dell'esecuzione del test](#how-to-use-reports-console-summary)
+ [Visualizza segnalazioni di problemi uniche](#how-to-use-reports-console-unique-problems)
+ [Visualizza i report sui dispositivi](#how-to-use-reports-console-by-device)
+ [Visualizza i report della suite di test](#how-to-use-reports-console-by-suite)
+ [Visualizzazione dei report di test](#how-to-use-reports-console-by-test)
+ [Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto](#how-to-use-reports-console-log)
### Visualizza la pagina di riepilogo dell'esecuzione del test
1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm)
1. **Nel riquadro di navigazione, scegli **Mobile Device Testing, quindi** scegli Progetti.**
1. Nell'elenco di progetti, scegli il progetto da eseguire.
**Suggerimento**
Per filtrare l'elenco dei progetti per nome, usa la barra di ricerca.
1. Scegli un'esecuzione completata per visualizzarne la pagina con il report dei riepiloghi.
1. La pagina di riepilogo delle esecuzioni dei test mostra una panoramica dei risultati dei test.
+ La sezione **Unique problems (Problemi univoci)** elenca gli avvisi e gli errori univoci. Per visualizzare i problemi univoci, segui le istruzioni contenute in [Visualizza segnalazioni di problemi uniche](#how-to-use-reports-console-unique-problems).
+ La sezione **Devices (Dispositivi)** mostra il numero totale di test, per risultato, per ogni dispositivo.
![\[Device Farm device summary results.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-device-summary-results-bar.png)
In questo esempio, ci sono diversi dispositivi. Nella prima voce della tabella, il dispositivo Google Pixel 4 XL con Android versione 10 riporta tre test riusciti, la cui esecuzione ha richiesto 02:36 minuti.
Per visualizzare i risultati per dispositivo, segui le istruzioni contenute in [Visualizza i report sui dispositivi](#how-to-use-reports-console-by-device).
+ La sezione **Screenshots** mostra un elenco di tutte le schermate acquisite da Device Farm durante l'esecuzione, raggruppate per dispositivo.
+ Nella sezione **Risultati dell'analisi, puoi scaricare il risultato** dell'analisi.
### Visualizza segnalazioni di problemi uniche
1. In **Unique problems (Problemi univoci)**, scegli il problema che desideri visualizzare.
1. Scegli il dispositivo. Il report include informazioni sul problema.
La sezione **Video** mostra una registrazione video scaricabile del test.
La sezione **Risultato** mostra il risultato del test. Lo stato è rappresentato dall'icona del risultato. Per ulteriori informazioni, consulta [Stati di un singolo test](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
La sezione **Logs** mostra tutte le informazioni registrate da Device Farm durante il test. Per visualizzare queste informazioni, segui le istruzioni contenute in [Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto](#how-to-use-reports-console-log).
La scheda **File** mostra un elenco di tutti i file associati al test (come i file di registro) che è possibile scaricare. Per scaricare un file, scegli il relativo link nell'elenco.
La scheda **Screenshots** mostra un elenco di tutte le schermate acquisite da Device Farm durante il test.
### Visualizza i report sui dispositivi
+ Nella sezione **Devices (Dispositivi)**, scegli il dispositivo.
La sezione **Video** mostra una registrazione video scaricabile del test.
La sezione **Suite** visualizza una tabella contenente informazioni sulle suite per il dispositivo.
In questa tabella, la colonna **Risultati dei test** riepiloga il numero di test per risultato per ciascuna delle suite di test eseguite sul dispositivo. Questi dati hanno anche una componente grafica. Per ulteriori informazioni, consulta [Stati per test multipli](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Per visualizzare i risultati completi per suite, segui le istruzioni riportate in[Visualizza i report della suite di test](#how-to-use-reports-console-by-suite).
La sezione **Logs** mostra tutte le informazioni che Device Farm ha registrato per il dispositivo durante l'esecuzione. Per visualizzare queste informazioni, segui le istruzioni contenute in [Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto](#how-to-use-reports-console-log).
La sezione **File** visualizza un elenco di suite per il dispositivo e tutti i file associati (come i file di registro) che è possibile scaricare. Per scaricare un file, scegli il relativo link nell'elenco.
La sezione **Screenshots** mostra un elenco di tutte le schermate acquisite da Device Farm durante l'esecuzione per il dispositivo, raggruppate per suite.
### Visualizza i report della suite di test
1. Nella sezione **Devices (Dispositivi)**, scegli il dispositivo.
1. Nella sezione **Suite**, scegli la suite dalla tabella.
La sezione **Video** mostra una registrazione video scaricabile del test.
La sezione **Test** mostra una tabella contenente informazioni sui test della suite.
Nella tabella, la colonna **Risultati dei test** mostra il risultato. Questi dati hanno anche una componente grafica. Per ulteriori informazioni, consulta [Stati per test multipli](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-summary).
Per visualizzare i risultati completi dei test, segui le istruzioni riportate in[Visualizzazione dei report di test](#how-to-use-reports-console-by-test).
La sezione **Logs** mostra tutte le informazioni registrate da Device Farm durante l'esecuzione della suite. Per visualizzare queste informazioni, segui le istruzioni contenute in [Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto](#how-to-use-reports-console-log).
La sezione **File** mostra un elenco di test per la suite e tutti i file associati (come i file di registro) che è possibile scaricare. Per scaricare un file, scegli il relativo link nell'elenco.
La sezione **Screenshots** mostra un elenco di tutte le schermate acquisite da Device Farm durante l'esecuzione della suite, raggruppate per test.
### Visualizzazione dei report di test
1. Nella sezione **Devices (Dispositivi)**, scegli il dispositivo.
1. Nella sezione **Suites (Suite)**, scegli la suite.
1. Nella sezione **Test**, scegli il test.
1. La sezione **Video** mostra una registrazione video scaricabile del test.
La sezione **Risultato** mostra il risultato del test. Lo stato è rappresentato dall'icona del risultato. Per ulteriori informazioni, consulta [Stati di un singolo test](how-to-use-reports-displaying-results.md#how-to-use-reports-displaying-results-individual).
La sezione **Logs** mostra tutte le informazioni registrate da Device Farm durante il test. Per visualizzare queste informazioni, segui le istruzioni contenute in [Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto](#how-to-use-reports-console-log).
La scheda **File** mostra un elenco di tutti i file associati al test (come i file di registro) che è possibile scaricare. Per scaricare un file, scegli il relativo link nell'elenco.
La scheda **Screenshots** mostra un elenco di tutte le schermate acquisite da Device Farm durante il test.
### Visualizza le informazioni di registro relative a un problema, un dispositivo, una suite o un test in un rapporto
La sezione **Registri** mostra le seguenti informazioni:
+ **Source (Origine)** indica l'origine di una voce di log. I valori possibili includono:
+ **Harness** rappresenta una voce di registro creata da Device Farm. Queste voci di registro vengono in genere create durante eventi di avvio e arresto.
+ **Device** rappresenta una voce di registro creata dal dispositivo. Per Android, queste voci di registro sono compatibili con logcat. Per iOS, queste voci di registro sono compatibili con syslog.
+ **Test** indica una voce di registro creata da un test o dal relativo framework.
+ **Time (Tempo)** indica il tempo trascorso tra la prima voce di log e questa. L'ora è espressa in un *MM:SS.SSS* formato, dove *M* rappresenta i minuti e *S* rappresenta i secondi.
+ **PID** indica l'identificatore del processo (PID) che ha creato la voce di log. Tutte le voci di log create da un'app su un dispositivo hanno lo stesso PID.
+ **Level (Livello)** indica il livello registrato per la voce di log. Ad esempio, `Logger.debug("This is a message!")` registra il **livello** `Debug`. I valori possibili sono:
+ **Avviso**
+ **Critico**
+ **Esegui il debug**
+ **Emergenza**
+ **Errore**
+ **Errore**
+ **Non riuscito**
+ **Informazioni**
+ **Interno**
+ **Comunicazione**
+ **Superato**
+ **Saltato**
+ **Arrestate**
+ **Modalità dettagliata**
+ **Notifica**
+ **Attenzione**
+ **Tag** indica metadati arbitrari per la voce di log. Ad esempio, il logcat Android può servirsene per descrivere quale parte del sistema ha creato la voce di log (ad esempio, `ActivityManager`).
+ **Message (Messaggio)** indica il messaggio o i dati per la voce di registro. Ad esempio, `Logger.debug("Hello, World!")` registra il valore **Message (Messaggio)** `"Hello, World!"`.
Per visualizzare solo una parte delle informazioni:
+ Per mostrare tutte le voci di registro che corrispondono a un valore per una colonna specifica, inserisci il valore nella barra di ricerca. Ad esempio, per mostrare tutte le voci di registro con un valore **Source** pari a`Harness`, **Harness** inseriscilo nella barra di ricerca.
+ Per rimuovere tutti i caratteri da un riquadro dell'intestazione di una colonna, seleziona la **X** in quel riquadro in questione. Rimuovere tutti i caratteri da una casella di intestazione di colonna equivale a inserirli **\$1** in quella casella di intestazione di colonna.
Per scaricare tutte le informazioni di registro per il dispositivo, incluse tutte le suite e i test che hai eseguito, scegli **Scarica** registri.
# Stati dei risultati del test Device Farm
La console Device Farm mostra icone che consentono di valutare rapidamente lo stato dell'esecuzione del test completata. Per ulteriori informazioni sui test in Device Farm, vedere[Report in AWS Device FarmReport](reports.md).
**Topics**
+ [Stati di un singolo test](#how-to-use-reports-displaying-results-individual)
+ [Stati per test multipli](#how-to-use-reports-displaying-results-summary)
## Stati di un singolo test
Per i report che descrivono un singolo test, Device Farm visualizza un'icona che rappresenta lo stato del risultato del test:
| Description | Icon |
| --- | --- |
| Il test ha avuto esito positivo. | ![\[The test succeeded.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-success.png) |
| Il test ha avuto esito negativo. | ![\[The test failed.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-failure.png) |
| Device Farm ha saltato il test. | ![\[The test was skipped.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-skipped.png) |
| Il test si è interrotto. | ![\[The test was stopped.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-stopped.png) |
| Device Farm ha restituito un avviso. | ![\[Device Farm returned a warning.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-warning.png) |
| Device Farm ha restituito un errore. | ![\[Device Farm returned an error.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-run-error.png) |
## Stati per test multipli
Se si sceglie un'esecuzione completata, Device Farm visualizza un grafico riassuntivo che mostra la percentuale di test nei vari stati.
![\[Device Farm test results summary graph.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/df-summary-results-graph.png)
Ad esempio, questo grafico dei risultati dell'esecuzione del test mostra che nella corsa sono stati interrotti 4 test interrotti, 1 test fallito e 10 test riusciti.
I grafici sono sempre codificati a colori ed etichettati.
# Scaricamento di artefatti in Device Farm
Device Farm raccoglie artefatti come report, file di registro e immagini per ogni test in esecuzione.
Puoi scaricare artefatti creati durante la sessione di test:
**File**
File generati durante l'esecuzione del test, inclusi i report di Device Farm. Per ulteriori informazioni, consulta [Visualizzazione dei report dei test in Device Farm](how-to-use-reports.md).
**Log**
Output da ciascun test nella sessione.
**Screenshot**
Immagini di schermata registrate per ogni test nella sessione.
![\[Workflow diagram showing Project, Run, Job (device), Test suite, and Test stages in Cloud AWS.\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/hierarchy.png)
## Scarica artefatti (console)
1. Nella pagina del report della sessione di test, da **Devices (Dispositivi)**, selezionare un dispositivo mobile.
1. Per scaricare un file, sceglierne uno da **Files (File)**.
1. Per scaricare i log dalla sessione di test, da **Logs (Log)**, selezionare **Download logs (Scarica log)**.
1. Per scaricare uno screenshot, scegliere uno screenshot da **Screenshots (Screenshot)**.
Per ulteriori informazioni su come scaricare gli artefatti in un ambiente di test personalizzato, consulta [Scaricamento di artefatti in un ambiente di test personalizzato](using-artifacts-custom.md).
## Scarica gli artefatti ()AWS CLI
Puoi usare il AWS CLI per elencare gli artefatti del test eseguito.
**Topics**
+ [Fase 1: Ottieni i tuoi Amazon Resource Names (ARN)](#artifacts-cli-step1)
+ [Fase 2: Elenca i tuoi artefatti](#artifacts-cli-step2)
+ [Passaggio 3: scarica i tuoi artefatti](#artifacts-cli-step3)
### Fase 1: Ottieni i tuoi Amazon Resource Names (ARN)
Puoi elencare i tuoi artefatti per sessione, lavoro, suite di test o test. Ti occorre l'ARN corrispondente. Questa tabella mostra l'ARN di input per ciascuno dei comandi dell' AWS CLI elenco:
| AWS CLI Comando di elenco | ARN richiesto |
| --- | --- |
| list-projects | Questo comando restituisce tutti i progetti e non richiede un ARN. |
| list-runs | project |
| list-jobs | run |
| list-suites | job |
| list-tests | suite |
Ad esempio, per trovare l'ARN di un test, esegui **list-tests** utilizzando l'ARN della tua suite di test come parametro di input.
Esempio:
```
aws devicefarm list-tests –-arn arn:MyTestSuiteARN
```
La risposta include un ARN di test per ogni test nella suite di test.
```
{
"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
}
}
]
}
```
### Fase 2: Elenca i tuoi artefatti
Il comando AWS CLI [list-artifacts](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/list-artifacts.html) restituisce un elenco di artefatti, come file, schermate e registri. Ogni artefatto dispone di un URL in modo che tu possa scaricare il file.
+ Chiama **list-artifacts** specificando l'ARN di una sessione, un lavoro, una suite di test o un test. Specifica un tipo di FILE, LOG o SCREENSHOT.
Questo esempio restituisce un URL di download per ogni artefatto disponibile per un singolo test:
```
aws devicefarm list-artifacts --arn arn:MyTestARN --type "FILE"
```
La risposta contiene un URL di download per ogni artefatto.
```
{
"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",
}
]
}
```
### Passaggio 3: scarica i tuoi artefatti
+ Scarica i tuoi artefatti utilizzando l'URL dalla fase precedente. Questo esempio utilizza **curl** per scaricare un file di output Android Appium Java:
```
curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyArtifactName.txt
```
## Scarica gli artefatti (API)
Il [ListArtifacts](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ListArtifacts.html)metodo API Device Farm restituisce un elenco di elementi, come file, schermate e registri. Ogni artefatto dispone di un URL in modo che tu possa scaricare il file.
# Scaricamento di artefatti in un ambiente di test personalizzato
In un ambiente di test personalizzato, Device Farm raccoglie artefatti come report personalizzati, file di registro e immagini. Questi artefatti sono disponibili per ciascun dispositivo nella sessione di test.
Puoi scaricare questi artefatti creati durante la sessione di test:
**Output di specifica di test**
L'output derivante dall'esecuzione dei comandi nel file YAML di specifica di test.
**Artefatti personalizzati**
Un file compresso che contiene gli artefatti della sessione di test. È configurato nella sezione **artifact: (artefatti:)** sezione del tuo file YAML di specifica di test.
**Script della shell di specifica di test**
Un file di script della shell intermedio creato dal tuo file YAML. Dato che è utilizzato nella sessione di test, il file di script della shell può essere utilizzato per il debug del file YAML.
**File di specifica di test**
Il file YAML utilizzato nella sessione di test.
Per ulteriori informazioni, consulta [Scaricamento di artefatti in Device Farm](artifacts.md).
![\[Gerarchia delle operazioni di Device Farm in un ambiente di test personalizzato\]](http://docs.aws.amazon.com/it_it/devicefarm/latest/developerguide/images/hierarchy.png)