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

Creazione di un'esecuzione di test in Device Farm

È possibile utilizzare la console Device Farm o Device Farm API per creare un'esecuzione di test. AWS CLI 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 Creazione di 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.
Scegli Next (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 Framework di test e test integrati 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 in AWS Device Farm.
Se stai utilizzando l'ambiente di test standard, passa alla fase 13. Se utilizzi un ambiente di test personalizzato con il YAML file delle specifiche di test predefinito, vai al passaggio 13.
1. Se desideri modificare la specifica di test predefinita in un ambiente di test personalizzato, scegli Modifica per aggiornare la specifica predefinita. YAML
2. Se hai modificato la specifica di test, scegli Salva come nuova per aggiornarla.
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.
Scegli Next (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 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.
Per ulteriori informazioni, consulta Supporto per dispositivi in AWS Device Farm.
Scegli 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 Wi-Fi, Bluetooth o NFC è abilitato durante la corsaGPS, accanto a Imposta gli stati della 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 locali.
Nota
L'impostazione dello stato radio e delle impostazioni locali del dispositivo sono opzioni disponibili solo per i test nativi di Android in questo momento.
Scegli Next (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 Impostazione del 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, consultaInterruzione di 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
Passaggio 5: (Facoltativo) Carica le specifiche di test personalizzate
Fase 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 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
        }
    ]
}

Scegli un progetto da associare all'esecuzione del test e prendi nota del relativo 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 tuoi pool di dispositivi, eseguilist-device-pools, specificando il tuo progettoARN.

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

Scegliete un pool di dispositivi e prendetene notaARN.

È 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 caricamento predefinito di Amazon Simple Storage Service (Amazon S3), devi: URL

Il tuo progetto. ARN
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 il caricamento dell'app ARN e un predefinito. URL


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

Prendi nota dell'app caricata ARN e di quella predefinitaURL.
Carica il file dell'app utilizzando Amazon S3 presigned. URL 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 nella Guida per l'utente di Amazon Simple Storage Service.

Per verificare lo stato del caricamento dell'app, esegui get-upload e specifica lo stato del caricamento ARN dell'app.


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 caricamento predefinito di Amazon S3URL, 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 il caricamento del pacchetto di test ARN e un pacchetto predefinito. URL


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

Prendi nota del ARN pacchetto di test caricato e del pacchetto URL prefirmato.
Carica il file del pacchetto degli script di test utilizzando il pacchetto Amazon URL S3 prefirmato. 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 di script di test, esegui get-upload e specifica il caricamento del pacchetto ARN di test dal passaggio 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}"
    }
}

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

Per trovare il caricamento ARN per le specifiche di test predefinite, esegui list-uploads e specifica il progetto. ARN


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. Prendi nota del suo caricamentoARN.
Per scaricare le specifiche di test predefinite, esegui get-upload e specifica il caricamentoARN.

Esempio:
```
aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN
```
La risposta contiene un predefinito URL in cui è possibile scaricare le specifiche di test predefinite.
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 delle specifiche di test personalizzate, esegui, specificando il nome della specifica di testcreate-upload, il tipo di specifica di test e il progetto. ARN

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 il caricamento e la prefirma delle specifiche di test: ARN URL


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

Prendi nota del caricamento e del ARN prefirmato delle specifiche per il test. URL
Carica il file delle specifiche di test utilizzando Amazon URL S3 presigned. 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 delle specifiche di test, esegui get-upload e specifica il caricamento. ARN


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 le specifiche di test personalizzate, eseguiupdate-upload, specificando il caricamento ARN per la specifica di test. Per ulteriori informazioni, consulta update-upload.

Fase 6: Pianifica un'esecuzione di test

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

Il progetto ARN della fase 1.
Il pool di dispositivi ARN del passaggio 2.
Il caricamento dell'app ARN dal passaggio 3.
Il caricamento del pacchetto di test ARN dal passaggio 4.

Se stai eseguendo test in un ambiente di test personalizzato, hai bisogno anche delle specifiche di test ARN del passaggio 5.

Per pianificare una sessione in un ambiente di test standard

Eseguischedule-run, specificando le informazioni sul progettoARN, sul pool di dispositiviARN, sul caricamento ARN dell'applicazione e sul 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'esecuzione ARN che puoi utilizzare per verificare lo stato dell'esecuzione del 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

Usa il get-run comando e specifica l'esecuzioneARN:


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 ScheduleRunAPI:

Un progettoARN. Consulta Crea un progetto (API) e CreateProject.
Caricamento di un'applicazioneARN. Per informazioni, consulta CreateUpload.
Un caricamento di un pacchetto di provaARN. Per informazioni, consulta CreateUpload.
Un pool di dispositiviARN. Consulta Creazione di un pool di dispositivi e CreateDevicePool.

Nota

Se esegui test in un ambiente di test personalizzato, devi anche caricare ARN le specifiche di test. Per ulteriori informazioni, consulta Passaggio 5: (Facoltativo) Carica le specifiche di test personalizzate e CreateUpload.

Per informazioni sull'utilizzo di Device FarmAPI, 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 Rapporti in AWS Device Farm.

Per utilizzare il rapporto, segui le istruzioni riportate in Visualizzazione dei report dei 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

Il test viene eseguito

Impostazione del timeout di esecuzione