Prerequisiti Crea un'esecuzione di test (console)Crea un test run (AWS CLI)Creare un test run (API)Passaggi successivi

Crea un'esecuzione di test in Device Farm

È possibile 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. Per informazioni sulle sessioni, consulta Esecuzioni.

Prerequisiti

È necessario disporre di un progetto in Device Farm. Segui le istruzioni riportate in Crea un progetto in AWS Device Farm, poi torna a questa pagina.

Crea un'esecuzione di test (console)

Accedere alla console Device Farm all'indirizzo https://console.aws.amazon.com/devicefarm.
Nel riquadro di navigazione, scegli Mobile Device Testing, quindi scegli Progetti.
Se è già stato creato un progetto, è possibile caricare i test. Altrimenti, scegliete Nuovo progetto, inserite un nome di progetto, quindi scegliete Crea.
Apri il progetto, quindi selezionare Create a new run (Crea una nuova sessione).
Nella pagina Scegli l'applicazione, scegli App per dispositivi mobili o App Web.
Caricare il file dell'applicazione. È inoltre possibile trascinare il file oppure selezionare un caricamento recente. Se si sta caricando un'app iOS, assicurarsi di selezionare iOS device (dispositivo iOS), invece di un simulatore.
(Opzionale) In Run name (Nome sessione), immettere un nome. Per impostazione predefinita, Device Farm utilizza il nome del file dell'app.
Seleziona Successivo.
Nella pagina Configure (Configura), selezionare una delle suite 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 Utilizzo dei tipi di test in AWS Device Farm.
Se non hai scelto Built-in: Fuzz, seleziona Scegli file, quindi cerca e scegli il file che contiene i test.
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.
Se stai utilizzando l'ambiente di test standard, passa alla fase 13. Se stai utilizzando un ambiente di test personalizzato con il file di specifica YAML di test predefinito, passa alla fase 13.
1. Se si desidera modificare il file di specifica predefinito in un ambiente di test personalizzato, selezionare Edit (Modifica) per aggiornare la specifica YAML predefinita.
2. Se hai modificato le specifiche del test, scegli Salva come nuovo per aggiornarle.
Se si desidera configurare la registrazione video o le prestazioni delle opzioni di acquisizione di dati, selezionare Advanced Configuration (Configurazione avanzata).
1. Seleziona Abilita la registrazione video per registrare video durante il test.
2. Seleziona Abilita l'acquisizione dei dati sulle prestazioni dell'app per acquisire i dati sulle prestazioni dal dispositivo.
Nota
Se disponi di dispositivi privati, viene visualizzata anche la configurazione specifica per i dispositivi privati.
Seleziona Successivo.
Nella pagina Select devices (Seleziona dispositivo), eseguire 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 Creare 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.
Per ulteriori informazioni, consulta la pagina Supporto per dispositivi in AWS Device Farm.
Seleziona Next (Successivo).
Nella pagina Specify device state (Specifica stato dispositivo):
- 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 Successivo.
Nella pagina Rivedi e avvia l'esecuzione, puoi specificare il timeout di esecuzione per l'esecuzione del test. Se si stanno utilizzando slot di test illimitati, controllare che Run on unmetered slots (Esegui su slot non misurati) sia selezionato.
Inserire un valore o utilizzare la barra di scorrimento per modificare il timeout di esecuzione. Per ulteriori informazioni, consulta Imposta il timeout di esecuzione per le esecuzioni di test in AWS Device Farm.
Selezionare Confirm and start run (Controlla e avvia sessione).

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 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. 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 si trasforma in un'icona del risultato del test.

Se desideri interrompere l'esecuzione del test, consultaInterrompi un'esecuzione in AWS Device Farm.

Crea un test run (AWS CLI)

È possibile utilizzare il AWS CLI per creare un'esecuzione di test.

Argomenti

Fase 1: Scegli un progetto
Passaggio 2: Scegli un pool di dispositivi
Passaggio 3: carica il file della tua candidatura
Passaggio 4: carica il pacchetto di script di test
Fase 5: (Facoltativo) Carica le specifiche di test personalizzate
Passaggio 6: Pianifica un'esecuzione di test

Fase 1: Scegli un progetto

È necessario associare l'esecuzione del test a un progetto Device Farm.

Per elencare i tuoi progetti Device Farm, eseguilist-projects. Se non disponi ancora di un progetto, consulta Crea 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
        }
    ]
}

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.

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

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

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 create-upload.

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

Prendere nota dell'ARN di caricamento dell'applicazione e dell'URL prefirmato.
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 URL predefiniti nella Guida per l'utente di Amazon Simple Storage Service.

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.

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

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

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.

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

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

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

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

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.

Passaggio 6: Pianifica un'esecuzione di test

Per pianificare un'esecuzione di test con AWS CLI, eseguischedule-run, specificando:

L'ARN del progetto dalla fase 1.
L'ARN del pool dei dispositivi dalla fase 2.
L'ARN di caricamento dell'applicazione dalla fase 3.
L'ARN di caricamento del pacchetto di test dalla fase 4.

Se si eseguono i test in un ambiente di test personalizzato, è necessario anche l'ARN della specifica di test dalla fase 5.

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

Per ulteriori informazioni, consulta get-run. Per informazioni sull'utilizzo di Device Farm con AWS CLI, vedereRiferimento AWS CLI .

Creare un test run (API)

I passaggi sono gli stessi descritti nella AWS CLI sezione. Per informazioni, consulta Crea un test run (AWS CLI).

Queste informazioni sono necessarie per chiamare l'API ScheduleRun:

Un ARN di progetto. Consulta Crea un progetto (API) e CreateProject.
Un ARN di caricamento dell'applicazione. Per informazioni, consulta CreateUpload.
Un ARN di caricamento del pacchetto di test. Per informazioni, consulta CreateUpload.
Un ARN del pool di dispositivi. Consulta Creare un pool di dispositivi e CreateDevicePool.

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, consulta Fase 5: (Facoltativo) Carica le specifiche di test personalizzate e CreateUpload.

Per informazioni sull'utilizzo dell'API Device Farm, vedereAutomazione di Device Farm.

Passaggi successivi

Nella console Device Farm, l'icona dell'orologio diventa un'icona del risultato, ad esempio successo al The test succeeded. termine dell'esecuzione. Al termine dei test, viene visualizzato un rapporto per la sessione. Per ulteriori informazioni, consulta Report in AWS Device Farm.

Per utilizzare il rapporto, segui le istruzioni riportate in Utilizzo dei report di test in Device Farm.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Utilizzo delle esecuzioni di test

Imposta il timeout di esecuzione