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à. # Framework di test e test integrati in AWS Device Farm Questa sezione descrive il supporto di Device Farm per i framework di test e i tipi di test integrati. Device Farm esegue test automatici caricando l'app e i test in un bucket Amazon S3 sicuro gestito dal servizio. Una volta caricato, attiva l'infrastruttura sottostante, inclusi [gli host di test](custom-test-environments-hosts.md) gestiti dai servizi, ed esegue i test in parallelo su più dispositivi. I risultati dei test vengono archiviati in un bucket S3 gestito dal servizio. Questa architettura si chiama **esecuzione lato servizio** ed è un modo rapido ed efficiente per eseguire test su host fisicamente vicini al dispositivo, senza dover gestire personalmente l'infrastruttura dell'host di test. Questo approccio si adatta bene ai test su molti dispositivi in modo indipendente, nonché ai test nel contesto di una pipeline. CI/CD Per ulteriori informazioni su come Device Farm esegue i test, vedere[Ambienti di test in AWS Device Farm](test-environments.md). **Nota** Per i tester Appium, potresti preferire eseguire i test Appium dal tuo ambiente locale. **Con una [sessione di accesso remoto](remote-access.md), puoi eseguire test Appium lato client.** [Per ulteriori informazioni, consulta Appium testing lato client.](appium-endpoint.md) ## Framework di test Device Farm supporta questi framework di test per l'automazione mobile: ### Framework di test delle applicazioni Android + [Test Appium automaticiIntegrazione con i test Appium](test-types-appium.md) + [Instrumentation](test-types-android-instrumentation.md) ### Framework di test delle applicazioni iOS + [Test Appium automaticiIntegrazione con i test Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest INTERFACCIA UTENTE](test-types-ios-xctest-ui.md) ### Framework di test delle applicazioni Web Le applicazioni Web sono supportate utilizzando Appium. Per ulteriori informazioni su come trasferire i test su Appium, consulta [Esegui automaticamente i test Appium in Device FarmIntegrazione dei test Appium con Device Farm](test-types-appium.md). ### Framework in un ambiente di test personalizzato Device Farm non fornisce supporto per la personalizzazione dell'ambiente di test per il XCTest framework. Per ulteriori informazioni, consulta [Ambienti di test personalizzati in AWS Device Farm](custom-test-environments.md). ### Supporto per la versione Appium Per i test eseguiti in un ambiente personalizzato, Device Farm supporta la versione 1 di Appium. Per ulteriori informazioni, consulta [Ambienti di test in AWS Device Farm](test-environments.md). ## Tipi di test integrati Con i test integrati, puoi testare la tua applicazione su più dispositivi senza dover scrivere e gestire script di automazione dei test. Device Farm offre un tipo di test integrato: + [Integrato: fuzz (Android e iOS)](test-types-built-in-fuzz.md) # Esegui automaticamente i test Appium in Device Farm **Nota** **Questa pagina descrive l'esecuzione dei test Appium nell'ambiente di esecuzione lato server gestito di Device Farm.** [Per eseguire i test Appium dal tuo ambiente locale lato **client durante una sessione di accesso remoto, consulta Appium testing lato** client.](appium-endpoint.md) Questa sezione descrive come configurare, impacchettare e caricare i test Appium per l'esecuzione nell'ambiente lato server gestito di Device Farm. Appium è uno strumento open source per automatizzare le applicazioni web native e mobili. Per ulteriori informazioni, vedere [Introduzione ad Appium sul sito Web di Appium.](http://appium.io/docs/en/latest/intro) Per un'app di esempio e i collegamenti ai test di lavoro, consulta [Device Farm Sample App per Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) e [Device Farm Sample App per iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) su GitHub. Per ulteriori informazioni sui test in Device Farm e sul funzionamento lato server, vedere. [Framework di test e test integrati in AWS Device Farm](test-types.md) ## Selezione di una versione di Appium **Nota** Il supporto per versioni Appium specifiche, driver Appium o programmazione SDKs dipenderà dal dispositivo e dall'host di test selezionati per l'esecuzione del test. Gli host di test Device Farm sono preinstallati con Appium per consentire una configurazione più rapida dei test per casi d'uso più semplici. Tuttavia, l'uso del file test spec consente di installare diverse versioni di Appium, se necessario. ### Scenario 1: versione Appium preconfigurata Device Farm è preconfigurato con diverse versioni del server Appium in base all'host di test. L'host è dotato di strumenti che abilitano la versione preconfigurata con il driver predefinito della piattaforma del dispositivo (UiAutomator2 per Android e per XCUITest iOS). ``` phases: install: commands: - export APPIUM_VERSION=2 - devicefarm-cli use appium $APPIUM_VERSION ``` Per visualizzare un elenco dei software supportati, consulta l'argomento su. [Software supportato in ambienti di test personalizzati](custom-test-environments-hosts-software.md) ### Scenario 2: versione Appium personalizzata Per selezionare una versione personalizzata di Appium, usa il `npm` comando per installarla. L'esempio seguente mostra come installare l'ultima versione di Appium 2. ``` phases: install: commands: - export APPIUM_VERSION=2 - npm install -g appium@$APPIUM_VERSION ``` ### Scenario 3: Appium su host iOS precedenti Su[Host di test iOS legacy](custom-test-environments-hosts-ios.md#legacy-ios-host), puoi scegliere versioni specifiche di Appium con. `avm` Ad esempio, per utilizzare il `avm` comando su cui impostare la versione del server Appium`2.1.2`, aggiungi questi comandi al file YAML della specifica di test. ``` phases: install: commands: - export APPIUM_VERSION=2.1.2 - avm $APPIUM_VERSION ``` ## Selezione di una WebDriverAgent versione per i test iOS Per eseguire i test Appium su dispositivi iOS, WebDriverAgent è necessario l'uso di. Questa applicazione deve essere firmata per poter essere installata su dispositivi iOS. Device Farm fornisce versioni prefirmate WebDriverAgent che sono disponibili durante le esecuzioni di ambienti di test personalizzati. Il seguente frammento di codice può essere utilizzato per selezionare una WebDriverAgent versione in Device Farm all'interno del file delle specifiche di test compatibile con la versione del driver XCTest UI. ``` phases: pre_test: commands: - |- APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1); CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}") if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2) else LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1) echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION"; DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2) fi; ``` [Per ulteriori informazioni su WebDriverAgent, consulta la documentazione di Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) # Integrazione dei test Appium con Device Farm Utilizza le seguenti istruzioni per integrare i test Appium con AWS Device Farm. Per ulteriori informazioni sull'utilizzo dei test Appium in Device Farm, vedere. [Esegui automaticamente i test Appium in Device FarmIntegrazione dei test Appium con Device Farm](test-types-appium.md) ## Configura il tuo pacchetto di test Appium Utilizza le seguenti istruzioni per configurare il pacchetto del test. ------ #### [ Java (JUnit) ] 1. Modifica `pom.xml` per impostare la confezione su un file JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifica `pom.xml` per utilizzarlo `maven-jar-plugin` per creare i test in un file JAR. Il seguente plugin crea il codice sorgente del test (qualsiasi cosa nella `src/test` directory) in un file JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifica `pom.xml` per utilizzarlo `maven-dependency-plugin` per creare dipendenze come file JAR. Il seguente plugin copia le tue dipendenze nella `dependency-jars` directory: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Salvate il seguente assembly XML in. `src/main/assembly/zip.xml` Il seguente codice XML è una definizione di assembly che, una volta configurata, indica a Maven di creare un file.zip che contenga tutto ciò che si trova nella radice della directory di output della build e della directory: `dependency-jars` ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifica `pom.xml` per utilizzarlo per `maven-assembly-plugin` impacchettare i test e tutte le dipendenze in un unico file.zip. Il seguente plugin utilizza l'assembly precedente per creare un file.zip denominato `zip-with-dependencies` nella directory di output della build ogni volta che viene eseguito: **mvn package** ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **Nota** Se ricevi un messaggio di errore indicante che l'annotazione non è supportata nella versione 1.3, aggiungi quanto segue a `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Java (TestNG) ] 1. Modifica `pom.xml` per impostare la confezione su un file JAR: ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifica `pom.xml` per utilizzarlo `maven-jar-plugin` per creare i test in un file JAR. Il seguente plugin crea il codice sorgente del test (qualsiasi cosa nella `src/test` directory) in un file JAR: ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifica `pom.xml` per utilizzarlo `maven-dependency-plugin` per creare dipendenze come file JAR. Il seguente plugin copia le tue dipendenze nella `dependency-jars` directory: ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Salvate il seguente assembly XML in. `src/main/assembly/zip.xml` Il seguente codice XML è una definizione di assembly che, una volta configurata, indica a Maven di creare un file.zip che contenga tutto ciò che si trova nella radice della directory di output della build e della directory: `dependency-jars` ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifica `pom.xml` per utilizzarlo per `maven-assembly-plugin` impacchettare i test e tutte le dipendenze in un unico file.zip. Il seguente plugin utilizza l'assembly precedente per creare un file.zip denominato `zip-with-dependencies` nella directory di output della build ogni volta che viene eseguito: **mvn package** ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **Nota** Se ricevi un messaggio di errore indicante che l'annotazione non è supportata nella versione 1.3, aggiungi quanto segue a `pom.xml`: ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Node.JS ] Per impacchettare i test di Appium Node.js e caricarli su Device Farm, è necessario installare quanto segue sul computer locale: + [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm) Utilizzare questo strumento per sviluppare e creare pacchetti di test in modo che inutili dipendenze non siano incluse nel pacchetto di test. + Node.js + npm-bundle (installato a livello globale) 1. Verificare che nvm sia presente ``` command -v nvm ``` Dovresti vedere `nvm` come output. Per ulteriori informazioni, vedere [nvm](https://github.com/nvm-sh/nvm) on. GitHub 1. Eseguire questo comando per installare Node.js: ``` nvm install node ``` È possibile specificare una determinata versione di Node.js: ``` nvm install 11.4.0 ``` 1. Verificare che la versione corretta di Node sia in uso: ``` node -v ``` 1. Installare **npm-bundle** globalmente: ``` npm install -g npm-bundle ``` ------ #### [ Python ] 1. Si consiglia vivamente di configurare un [virtualenv Python](https://pypi.python.org/pypi/virtualenv) per lo sviluppo e di impacchettare i test in modo che le dipendenze non necessarie siano escluse dal pacchetto dell'applicazione. ``` $ virtualenv workspace $ cd workspace $ source bin/activate ``` **Suggerimento** Non creare un virtualenv Python con l'opzione `--system-site-packages`, in quanto eredita pacchetti dalla directory site-packages globale. Questo può causare l'inclusione di dipendenze nell'ambiente virtuale non richieste dai test. Verificare inoltre che i test non utilizzino dipendenze dipendenti da librerie native, in quanto queste librerie native potrebbero non essere presenti sull'istanza in cui sono eseguiti i test. 1. Installare **py.test** nell'ambiente virtuale. ``` $ pip install pytest ``` 1. Installare il client Appium Python nell'ambiente virtuale. ``` $ pip install Appium-Python-Client ``` 1. A meno che non si specifichi un percorso diverso in modalità personalizzata, Device Farm prevede che i test vengano archiviati in`tests/`. È possibile utilizzare `find` per mostrare tutti i file all'interno di una cartella: ``` $ find tests/ ``` Verifica che questi file contengano suite di test che desideri eseguire su Device Farm ``` tests/ tests/my-first-tests.py tests/my-second-tests/py ``` 1. Eseguire questo comando dalla cartella dell'area di lavoro dell'ambiente virtuale in modo da visualizzare un elenco di test senza eseguirli. ``` $ py.test --collect-only tests/ ``` Conferma che l'output mostri i test che desideri eseguire su Device Farm. 1. Pulire tutti i file memorizzati nella cache nella cartella dei test: ``` $ find . -name '__pycache__' -type d -exec rm -r {} + $ find . -name '*.pyc' -exec rm -f {} + $ find . -name '*.pyo' -exec rm -f {} + $ find . -name '*~' -exec rm -f {} + ``` 1. Eseguire il comando seguente nell'area di lavoro, per generare il file requirements.txt: ``` $ pip freeze > requirements.txt ``` ------ #### [ Ruby ] Per impacchettare i test di Appium Ruby e caricarli su Device Farm, è necessario installare quanto segue sul computer locale: + [Ruby Version Manager (RVM)](https://rvm.io/rvm/install) Utilizzare questo strumento a riga di comando per sviluppare e creare pacchetti di test in modo che inutili dipendenze non siano incluse nel pacchetto di test. + Ruby + Bundler (viene in genere installato con Ruby). 1. Installare le chiavi richieste, RVM e Ruby. Per istruzioni, consulta [Installazione di RVM](https://rvm.io/rvm/install) sul sito Web relativo. Una volta completata l'installazione, ricaricare il terminale uscendo e accedendo nuovamente. **Nota** RVM è caricato come funzione solo per shell bash. 1. Verifica che **rvm** sia installato correttamente. ``` command -v rvm ``` Dovresti vedere `rvm` come output. 1. Se vuoi installare una versione specifica di Ruby, ad esempio*2.5.3*, esegui il seguente comando: ``` rvm install ruby 2.5.3 --autolibs=0 ``` Verificare di utilizzare la versione richiesta di Ruby: ``` ruby -v ``` 1. Configura il bundler per compilare i pacchetti per le piattaforme di test desiderate: ``` bundle config specific_platform true ``` 1. Aggiorna il file.lock per aggiungere le piattaforme necessarie per eseguire i test. + Se stai compilando test da eseguire su dispositivi Android, esegui questo comando per configurare Gemfile in modo che utilizzi le dipendenze per l'host di test Android: ``` bundle lock --add-platform x86_64-linux ``` + Se stai compilando test da eseguire su dispositivi iOS, esegui questo comando per configurare Gemfile in modo che utilizzi le dipendenze per l'host di test iOS: ``` bundle lock --add-platform x86_64-darwin ``` 1. La gemma **bundler** viene solitamente installata per impostazione predefinita. Se non lo è, installa tale elemento: ``` gem install bundler -v 2.3.26 ``` ------ ## Crea un file di pacchetto di test compresso **avvertimento** In Device Farm, la struttura delle cartelle dei file nel pacchetto di test compresso è importante e alcuni strumenti di archiviazione modificheranno implicitamente la struttura del file ZIP. Ti consigliamo di seguire le utilità della riga di comando specificate di seguito anziché utilizzare le utilità di archiviazione integrate nel file manager del desktop locale (come Finder o Windows Explorer). Ora, raggruppare i test per Device Farm. ------ #### [ Java (JUnit) ] Creare i test: ``` $ mvn clean package -DskipTests=true ``` Come risultato, verrà creato il file `zip-with-dependencies.zip`. Questo è il pacchetto di test. ------ #### [ Java (TestNG) ] Creare i test: ``` $ mvn clean package -DskipTests=true ``` Come risultato, verrà creato il file `zip-with-dependencies.zip`. Questo è il pacchetto di test. ------ #### [ Node.JS ] 1. Verifica il progetto. Assicurati di essere nella directory principale del progetto. È possibile visualizzare `package.json` nella directory principale. 1. Esegui il comando per l'installazione delle dipendenze locali. ``` npm install ``` Questo comando crea inoltre una cartella `node_modules` all'interno della directory corrente. **Nota** A questo punto dovresti essere in grado di eseguire i test in locale. 1. Esegui il comando per creare pacchetti di file nella cartella corrente .tgz\$1. Il file è denominato utilizzando la proprietà `name` nel file `package.json`. ``` npm-bundle ``` Questo file tarball (.tgz) contiene tutti i codici e le dipendenze. 1. Esegui il comando per creare un bundle di tarball (\$1 file.tgz) generato nel passo precedente in un singolo archivio compresso: ``` zip -r MyTests.zip *.tgz ``` Questo è il `MyTests.zip` file che si carica su Device Farm con la procedura seguente. ------ #### [ Python ] Python 2 Generare un archivio dei pacchetti Python richiesti (chiamato "wheelhouse") usando pip: ``` $ pip wheel --wheel-dir wheelhouse -r requirements.txt ``` Creare il pacchetto dei requisiti di wheelhouse, test e pip in un archivio zip per Device Farm: ``` $ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt ``` Python 3 Creare il pacchetto dei requisiti di test e pip in un file zip: ``` $ zip -r test_bundle.zip tests/ requirements.txt ``` ------ #### [ Ruby ] 1. Esegui questo comando per creare un ambiente Ruby virtuale: ``` # myGemset is the name of your virtual Ruby environment rvm gemset create myGemset ``` 1. Esegui questo comando per utilizzare l'ambiente appena creato: ``` rvm gemset use myGemset ``` 1. Consulta il codice sorgente. Assicurati di essere nella directory principale del progetto. È possibile visualizzare `Gemfile` nella directory principale. 1. Esegui questo comando per l'installazione delle dipendenze locali e di tutte le gemme da `Gemfile`. ``` bundle install ``` **Nota** A questo punto dovresti essere in grado di eseguire i test in locale. Utilizzare questo comando per eseguire un test in locale: ``` bundle exec $test_command ``` 1. Crea un pacchetto delle gemme nella cartella `vendor/cache`. ``` # This will copy all the .gem files needed to run your tests into the vendor/cache directory bundle package --all-platforms ``` 1. Eseguire il comando seguente per il bundle del codice sorgente, insieme a tutte le tue dipendenze, in un singolo archivio compresso: ``` zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files) ``` Questo è il `MyTests.zip` file che si carica su Device Farm con la procedura seguente. ------ ## Carica il tuo pacchetto di test su Device Farm Puoi usare la console Device Farm per caricare i tuoi 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 sei un nuovo utente, scegli **Nuovo progetto**, inserisci un nome per il progetto, quindi scegli **Invia**. Se hai già un progetto, puoi sceglierlo per caricarvi i test. 1. Apri il progetto, quindi scegli **Crea esegui**. 1. In **Impostazioni di esecuzione**, assegna al test un nome appropriato. Tale nome può contenere qualsiasi combinazione di spazi o punteggiatura. 1. Per i test nativi di Android e iOS In **Impostazioni Esegui**, scegli **app Android** se stai testando un'applicazione Android (.apk) o scegli **app iOS** se stai testando un'applicazione iOS (.ipa). Quindi, in **Seleziona app**, seleziona **Carica la tua app** per caricare il pacchetto distribuibile dell'applicazione. Il file deve essere un file `.apk` Android oppure un file `.ipa` iOS. Le applicazioni iOS devono essere costruite per dispositivi reali, non per il simulatore. Per i test delle applicazioni Web per dispositivi mobili In **Impostazioni di esecuzione**, scegli **App Web**. 1. In **Configura test**, nella sezione **Seleziona il framework di test**, scegli il framework Appium con cui esegui il test, quindi **carica il tuo pacchetto di test**. 1. Individua e seleziona il file .zip che contiene i test. Il file .zip deve presentare il formato descritto in [Configura il tuo pacchetto di test Appium](#test-types-appium-prepare). 1. Segui le istruzioni per selezionare i dispositivi e iniziare l'esecuzione. Per ulteriori informazioni, consulta [Creazione di un'esecuzione di test in Device Farm](how-to-create-test-run.md). **Nota** Device Farm non modifica i test Appium. ## Acquisisci schermate dei tuoi test (opzionale) Durante i test, è possibile acquisire screenshot. Device Farm imposta la proprietà `DEVICEFARM_SCREENSHOT_PATH` su percorso pienamente qualificato sul sistema locale di file in cui Device Farm si aspetta il salvataggio degli screenshot Appium. La directory specifica del test in cui sono archiviati gli screenshot è definita in fase di esecuzione. Gli screenshot vengono recuperati automaticamente nei report Device Farm. Per visualizzare gli screenshot, nella console Device Farm, selezionare la sezione **Screenshots (Screenshot)**. Per ulteriori informazioni sull'acquisizione di screenshot nei test Appium, vedere [Acquisizione di screenshot](http://appium.io/docs/en/commands/session/screenshot/) nella documentazione dell'API Appium. # Test Android in AWS Device Farm Device Farm fornisce supporto per diversi tipi di test di automazione per dispositivi Android e due test integrati. Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). ## Framework di test delle applicazioni Android Sono disponibili i seguenti test per i dispositivi Android. + [Test Appium automaticiIntegrazione con i test Appium](test-types-appium.md) + [Instrumentation](test-types-android-instrumentation.md) ## Tipi di test integrati per Android È disponibile un tipo di test integrato per i dispositivi Android: + [Integrato: fuzz (Android e iOS)](test-types-built-in-fuzz.md) # Strumentazione per Android e AWS Device Farm Device Farm fornisce supporto per Instrumentation (JUnit, Espresso, Robotium o qualsiasi test basato su strumentazione) per Android. Device Farm fornisce anche un'applicazione Android di esempio e collegamenti a test di lavoro in tre framework di automazione Android, tra cui Instrumentation (Espresso). L'[app di esempio Device Farm per Android](https://github.com/awslabs/aws-device-farm-sample-app-for-android) è disponibile per il download su GitHub. Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). **Topics** + [Che cos'è la strumentazione?](#test-types-android-instrumentation-what-is) + [Considerazioni per i test di strumentazione Android](#test-types-android-instrumentation-settings) + [Analisi dei test in modalità standard](#test-types-android-standard-mode-test-parse) + [Integrazione della strumentazione Android con Device Farm](test-types-android-instrumentation-integrate.md) ## Che cos'è la strumentazione? Instrumentation di Android consente di invocare metodi di callback nel codice di test in modo da poter eseguire tutto il ciclo di vita di un componente passo-passo, come se si stesse effettuando il debug del componente. Per ulteriori informazioni, consulta [Test strumentati](https://developer.android.com/studio/test/test-in-android-studio#test_types_and_locations) nella sezione *Tipi e posizioni dei test* della documentazione di *Android Developer Tools*. ## Considerazioni per i test di strumentazione Android Quando utilizzi la strumentazione Android, prendi in considerazione i seguenti consigli e note. **Verifica la compatibilità del sistema operativo Android** Consulta la [documentazione di Android](https://developer.android.com/jetpack/androidx/releases/test#orchestrator-1.5.0) per assicurarti che Instrumentation sia compatibile con la versione del tuo sistema operativo Android. **Esecuzione dalla riga di comando** Per eseguire i test di Instrumentation dalla riga di comando, segui la documentazione di [Android](https://developer.android.com/training/testing/instrumented-tests/androidx-test-libraries/runner#enable-command). **System Animations (Animazioni di sistema)** Secondo la [documentazione Android per i test di Espresso](https://developer.android.com/training/testing/espresso), si consiglia di disattivare le animazioni di sistema durante i test su dispositivi reali. Device Farm disattiva automaticamente le impostazioni **Window Animation Scale**, **Transition Animation Scale e Animator** **Duration Scale quando viene eseguito con il test** runner di strumentazione [JUnitandroid.support.test.runner.Android](http://developer.android.com/reference/android/support/test/runner/AndroidJUnitRunner.html) Runner. **Test Recorders (Registratori di test)** Device Farm supporta framework, come Robotium, che dispongono record-and-playback di strumenti di scripting. ## Analisi dei test in modalità standard Nella modalità standard di esecuzione, Device Farm analizza la suite di test e identifica le classi e i metodi di test univoci che verrà eseguita. Questo viene fatto tramite uno strumento chiamato [Dex Test Parser](https://github.com/linkedin/dex-test-parser). Quando viene fornito un file.apk della strumentazione Android come input, il parser restituisce i nomi completi dei metodi dei test che corrispondono JUnit alle convenzioni 3 e 4. JUnit Per testarlo in un ambiente locale: 1. Scarica il file [https://github.com/linkedin/dex-test-parser](https://github.com/linkedin/dex-test-parser)binario. 1. Esegui il comando seguente per ottenere l'elenco dei metodi di test che verranno eseguiti su Device Farm: ``` java -jar parser.jar path/to/apk path/for/output ``` # Integrazione della strumentazione Android con Device Farm **Nota** Utilizza le seguenti istruzioni per integrare i test della strumentazione Android con AWS Device Farm. Per ulteriori informazioni sull'utilizzo dei test di strumentazione in Device Farm, vedere. [Strumentazione per Android e AWS Device Farm](test-types-android-instrumentation.md) ## Carica i tuoi test di strumentazione Android Usa la console Device Farm per caricare i 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. Nell'elenco dei progetti, scegli il progetto su cui caricare i test. **Suggerimento** Puoi utilizzare la barra di ricerca per filtrare l'elenco dei progetti per nome. Per creare un progetto, segui le istruzioni indicate nella sezione [Creazione di un progetto in AWS Device Farm](how-to-create-project.md). 1. Seleziona **Crea esegui**. 1. In **Seleziona app**, nella sezione **Opzioni di selezione dell'app**, seleziona **Carica la tua app**. 1. Individua e seleziona il file dell'app Android. Il file deve essere di tipo .apk. 1. In **Configura test**, nella sezione **Select test framework**, scegli **Strumentazione**, quindi seleziona **Scegli** file. 1. Individuare e selezionare il file .apk che contiene i test. 1. Completa le istruzioni rimanenti per selezionare i dispositivi e avviare l'esecuzione. ## (Facoltativo) Acquisisci schermate nei test della strumentazione Android Durante i test di Instrumentation per Android, si possono acquisire screenshot. Per acquisire screenshot, chiamare uno dei seguenti metodi: + Per Robotium, chiamare il metodo `takeScreenShot` (ad esempio, `solo.takeScreenShot();`). + Per Spoon, chiamare il metodo `screenshot`, ad esempio: ``` Spoon.screenshot(activity, "initial_state"); /* Normal test code... */ Spoon.screenshot(activity, "after_login"); ``` Durante un'esecuzione di test, Device Farm ottiene schermate dalle seguenti posizioni sui dispositivi, se esistono, e quindi le aggiunge ai rapporti di test: + `/sdcard/robotium-screenshots` + `/sdcard/test-screenshots` + `/sdcard/Download/spoon-screenshots/test-class-name/test-method-name` + `/data/data/application-package-name/app_spoon-screenshots/test-class-name/test-method-name` # Test iOS in AWS Device Farm Device Farm fornisce supporto per diversi tipi di test di automazione per dispositivi iOS e un test integrato. Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). ## Framework di test delle applicazioni iOS Sono disponibili i seguenti test per i dispositivi iOS. + [Test Appium automaticiIntegrazione con i test Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest INTERFACCIA UTENTE](test-types-ios-xctest-ui.md) ## Tipi di test integrati per iOS Attualmente è disponibile un tipo di test integrato per i dispositivi iOS. + [Integrato: fuzz (Android e iOS)](test-types-built-in-fuzz.md) # Integrazione di Device Farm con XCTest iOS Con Device Farm, puoi utilizzare il XCTest framework per testare la tua app su dispositivi reali. Per ulteriori informazioni in merito XCTest, consulta [Testing Basics](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/03-testing_basics.html) in *Testing with Xcode*. Per eseguire un test, create i pacchetti per l'esecuzione del test e caricate questi pacchetti su Device Farm. Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). **Topics** + [Crea i pacchetti per la tua XCTest corsa](#test-types-ios-xctest-create-packages) + [Carica i pacchetti per la tua XCTest corsa su Device Farm](#test-types-ios-xctest-upload) ## Crea i pacchetti per la tua XCTest corsa Per testare la tua app utilizzando il XCTest framework, Device Farm richiede quanto segue: + Il pacchetto dell'app come file `.ipa`. + Il tuo XCTest pacchetto come `.zip` file. È possibile creare questi pacchetti utilizzando l'output di compilazione generato da Xcode. Completa i seguenti passaggi per creare i pacchetti in modo da poterli caricare su Device Farm. **Per generare l'output di compilazione per l'app** 1. Aprire il progetto di app in Xcode. 1. Nel menu a discesa dello schema nella barra degli strumenti di Xcode, scegliere **Generic iOS Device (Dispositivo iOS generico)** come destinazione. 1. Nel menu **Product (Prodotto)** scegliere **Build For (Compilazione per)** e selezionare **Testing (Test)**. **Per creare il pacchetto di app** 1. Nel navigatore di progetto in Xcode, aprire sotto **Products (Prodotti)** il menu contestuale per il file denominato `app-project-name.app`. Quindi, scegliere **Show in Finder (Mostra in Finder)**. Finder apre una cartella denominata `Debug-iphoneos`, che contiene l'output generato da Xcode per la compilazione di test. Questa cartella include il file `.app`. 1. In Finder, creare una nuova cartella e denominarla `Payload`. 1. Copiare il file `app-project-name.app` e incollarlo nella cartella `Payload`. 1. Aprire il menu contestuale per la cartella `Payload` e selezionare **Compress "Payload" (Comprimi "Payload")**. Viene creato un file denominato `Payload.zip`. 1. Sostituire il nome file e l'estensione di `Payload.zip` con `app-project-name.ipa`. In una fase successiva, fornirete questo file a Device Farm. Per rendere il file più facile da trovare, è possibile spostarlo in un'altra posizione, ad esempio sul desktop. 1. Facoltativamente, è possibile eliminare la cartella `Payload` e il file `.app` che contiene. **Per creare il XCTest pacchetto** 1. In Finder, aprire nella directory `Debug-iphoneos` il menu contestuale per il file `app-project-name.app`. Quindi, scegliere **Show Package Contents (Mostra contenuti pacchetto)**. 1. Nei contenuti del pacchetto, aprire la cartella `Plugins`. Questa cartella contiene un file denominato `app-project-name.xctest`. 1. Aprire il menu contestuale per questo file e scegliere **Compress "`app-project-name.xctest`" (Comprimi "app-project-name.xctest")**. Viene creato un file denominato `app-project-name.xctest.zip`. In una fase successiva, fornirete questo file a Device Farm. Per rendere il file più facile da trovare, è possibile spostarlo in un'altra posizione, ad esempio sul desktop. ## Carica i pacchetti per la tua XCTest corsa su Device Farm Usa la console Device Farm per caricare i pacchetti per il test. 1. Accedere alla console Device Farm all'indirizzo [https://console.aws.amazon.com/devicefarm.](https://console.aws.amazon.com/devicefarm) 1. Se non si dispone già di un progetto, creane uno. Per la procedura per creare un progetto, consultare [Creazione di un progetto in AWS Device Farm](how-to-create-project.md). Altrimenti, nel pannello di navigazione di Device Farm, scegli **Mobile Device Testing**, quindi scegli **Progetti**. 1. Scegli il progetto che desideri utilizzare per eseguire il test. 1. Scegli **Crea esegui**. 1. In **Impostazioni di esecuzione**, nella sezione **Tipo di esecuzione**, scegli **l'app iOS**. 1. In **Seleziona app**, nella sezione **Opzioni di selezione dell'app**, seleziona **Carica la tua app**. Quindi, seleziona **Scegli file** in **Carica app**. 1. Individuare il file `.ipa` per l'app e caricarlo. **Nota** Il pacchetto `.ipa` deve essere compilato per il test. 1. In **Configura test**, nella sezione **Seleziona framework di test**, scegli **XCTest**. Quindi, seleziona **Scegli file** in **Carica app**. 1. Cerca il `.zip` file che contiene il XCTest pacchetto per la tua app e caricalo. 1. Completare le fasi rimanenti del processo di creazione del progetto. Sarà quindi possibile selezionare i dispositivi che si desidera testare e specificare lo stato del dispositivo. 1. Scegli **Crea esegui**. Device Farm esegue il test e mostra i risultati nella console. # Integrazione dell' XCTest interfaccia utente per iOS con Device Farm Device Farm fornisce supporto per il framework di test XCTest dell'interfaccia utente. [In particolare, Device Farm supporta i test XCTest dell'interfaccia utente scritti sia in Objective-C che in Swift.](https://developer.apple.com/swift/) Il framework dell' XCTest interfaccia utente consente il test dell'interfaccia utente nello sviluppo di iOS, basato su XCTest. Per ulteriori informazioni, consulta la sezione [User Interface Testing](https://developer.apple.com/library/prerelease/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/09-ui_testing.html#//apple_ref/doc/uid/TP40014132-CH13-SW1) nella libreria per sviluppatori di iOS. Per informazioni generali sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). Utilizza le seguenti istruzioni per integrare Device Farm con il framework di test dell' XCTest interfaccia utente per iOS. **Topics** + [Prepara i test XCTest dell'interfaccia utente iOS](#test-types-ios-xctest-ui-prepare) + [Opzione 1: creazione di un pacchetto XCTest UI .ipa](#how-to-use-create-XCTestUI-ipa-package) + [Opzione 2: creazione di un pacchetto XCTest UI con estensione zip](#how-to-use-create-XCTestUI-zip-package) + [Carica i test XCTest dell'interfaccia utente iOS](#test-types-ios-xctest-ui-upload) ## Prepara i test XCTest dell'interfaccia utente iOS Puoi caricare un `.ipa` file o un `.zip` file per il tuo pacchetto di test XCTEST\$1UI. Un `.ipa` file è un archivio di applicazioni contenente l'app iOS Runner in formato bundle. *Non è possibile includere file aggiuntivi all'interno del `.ipa` file.* Se carichi un `.zip` file, può contenere direttamente l'app iOS Runner o un `.ipa` file. Puoi anche includere altri file all'interno del `.zip` file se desideri utilizzarli durante i test. Ad esempio`.xctestrun`, puoi includere file come `.xcworkspace` o `.xcodeproj` all'interno `.zip` del file per eseguire i piani di test XCUI nella device farm. Istruzioni dettagliate su come eseguire i piani di test sono disponibili nel file delle specifiche di test predefinito per il tipo di test XCUI. ## Opzione 1: creazione di un pacchetto XCTest UI .ipa Il bundle *yourAppName*UITest-Runner.app viene prodotto da Xcode quando crei il tuo progetto per i test. Si trova nella directory Products per il progetto. Per creare un file.ipa: 1. Crea una directory chiamata. *Payload* 1. Aggiungi la directory dell'app alla directory Payload. 1. Archivia la directory Payload in un `.zip` file, quindi modifica l'estensione del file in. `.ipa` La seguente struttura di cartelle mostra come un'app di esempio denominata *my-project-nameUITest-Runner.app* verrebbe impacchettata come `.ipa` file: ``` . └── my-project-nameUITest.ipa └── Payload (directory) └── my-project-nameUITest-Runner.app ``` ## Opzione 2: creazione di un pacchetto XCTest UI con estensione zip Device Farm genera automaticamente un `.xctestrun` file per l'esecuzione della suite di test XCTest dell'interfaccia utente completa. Se desideri utilizzare il tuo `.xctestrun` file su Device Farm, puoi comprimere `.xctestrun` i file e la directory dell'app in un `.zip` file. Se hai già un `.ipa` file per il tuo pacchetto di test, puoi includerlo qui invece di*\$1-Runner.app*. ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── SampleTestPlan_2.xctestrun ├── SampleTestPlan_1.xctestrun └── (any other files) ``` Se desideri eseguire un piano di test Xcode per i tuoi test XCUI su Device Farm, puoi creare uno zip contenente il file *my-project-nameUITest-Runner.app **o my-project-name** UITest .ipa* *e i file di codice sorgente xcode necessari per eseguire XCTEST\$1UI con piani di test, incluso un* file or. `.xcworkspace` `.xcodeproj` Ecco un esempio di zip che utilizza un file: `.xcodeproj` ``` . └── swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa ├── (any directory) └── SampleXcodeProject.xcodeproj ├── Testplan_1.xctestplan ├── Testplan_2.xctestplan └── (any other source code files created by xcode with .xcodeproj) ``` Ecco un esempio di zip che utilizza un `.xcworkspace` file: ``` . └──swift-sample-UI.zip (directory) ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa └── (any directory) │ ├── SampleXcodeProject.xcodeproj │ ├── Testplan_1.xctestplan │ ├── Testplan_2.xctestplan | └── (any other source code files created by xcode with .xcodeproj) └── SampleWorkspace.xcworkspace └── contents.xcworkspacedata ``` **Nota** Assicurati di non avere una directory denominata «Payload» all'interno del pacchetto XCTest UI .zip. ## Carica i test XCTest dell'interfaccia utente iOS Usa la console Device Farm per caricare i 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. Nell'elenco dei progetti, scegli il progetto su cui caricare i test. **Suggerimento** Puoi utilizzare la barra di ricerca per filtrare l'elenco dei progetti per nome. Per creare un progetto, segui le istruzioni in [Creazione di un progetto in AWS Device Farm](how-to-create-project.md) 1. Scegli **Crea esegui**. 1. In **Impostazioni di esecuzione**, nella sezione **Tipo di esecuzione**, scegli **l'app iOS**. 1. In **Seleziona app**, nella sezione **Opzioni di selezione dell'app**, seleziona **Carica la tua app**. Quindi, seleziona **Scegli file** in **Carica app**. 1. Individuare e selezionare il file dell'app iOS. Il file deve essere un file .ipa. **Nota** Assicurati che il file .ipa sia integrato per un dispositivo iOS e non per un simulatore. 1. In **Configura test**, nella sezione **Seleziona framework di test**, scegli **XCTest UI**. Quindi, seleziona **Scegli file** in **Carica app**. 1. Cerca e scegli il file.ipa o.zip che contiene il tuo test runner XCTest dell'interfaccia utente iOS. 1. Completa i passaggi rimanenti del processo di creazione dell'esecuzione. Selezionerai i dispositivi su cui desideri eseguire il test e, facoltativamente, specificherai una configurazione aggiuntiva. 1. Scegli **Crea esegui**. Device Farm esegue il test e mostra i risultati nella console. # Test di app Web in AWS Device Farm Device Farm fornisce test con Appium per applicazioni web. Per ulteriori informazioni sulla configurazione dei test Appium su Device Farm, consulta. [Esegui automaticamente i test Appium in Device Farm](test-types-appium.md) Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). ## Regole per i dispositivi misurati e non misurati Per misurazione si intende la fatturazione per i dispositivi. Per impostazione predefinita, i dispositivi Device Farm vengono misurati e ti viene addebitato un addebito al minuto una volta esauriti i minuti di prova gratuiti. Puoi anche scegliere di acquistare dispositivi non misurati, per effettuare test illimitatamente a un costo mensile fisso. Per ulteriori informazioni sui prezzi, consulta la pagina dei [prezzi di AWS Device Farm](https://aws.amazon.com/device-farm/). Se decidi di avviare una sessione con un pool di dispositivi che contiene sia dispositivi iOS che Android, sono previste regole per i dispositivi misurati e non misurati. Ad esempio, se sono presenti cinque dispositivi Android non misurati e cinque dispositivi iOS non misurati, le sessioni di test Web utilizzano i dispositivi non misurati. Ecco un altro esempio: supponiamo di avere cinque dispositivi Android non misurati e 0 dispositivi iOS non misurati. Se selezioni solo i dispositivi Android per la sessione Web, vengono utilizzati i dispositivi non misurati. Se si selezionano entrambi i dispositivi Android e iOS per la sessione Web, il metodo di fatturazione viene misurato e i dispositivi non misurati non vengono utilizzati. # Test integrati in AWS Device Farm Device Farm fornisce supporto per tipi di test integrati per dispositivi Android e iOS. Grazie ai test integrati, puoi testare la tua applicazione su più dispositivi senza dover scrivere e gestire script di automazione dei test. Questo può farti risparmiare tempo e fatica, soprattutto quando inizi a usare Device Farm. Device Farm offre il seguente tipo di test integrato: + [Integrato: fuzz (Android e iOS)](test-types-built-in-fuzz.md)— Il fuzz test invia in modo casuale gli eventi dell'interfaccia utente ai dispositivi e quindi riporta i risultati. Per ulteriori informazioni sui test e sui framework di test in Device Farm, vedere. [Framework di test e test integrati in AWS Device Farm](test-types.md) # Esecuzione del fuzz test integrato di Device Farm (Android e iOS) Il fuzz test integrato di Device Farm invia in modo casuale gli eventi dell'interfaccia utente ai dispositivi e quindi riporta i risultati. Per ulteriori informazioni sui test in Device Farm, vedere[Framework di test e test integrati in AWS Device Farm](test-types.md). **Per eseguire il fuzz test integrato** 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, scegli il progetto in cui desideri eseguire il fuzz test integrato. **Suggerimento** Puoi usare la barra di ricerca per filtrare l'elenco dei progetti per nome. Per creare un progetto, segui le istruzioni indicate nella sezione [Creazione di un progetto in AWS Device Farm](how-to-create-project.md). 1. Scegli **Crea esegui**. 1. In **Impostazioni di esecuzione**, seleziona il tipo di corsa nella sezione **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). 1. In **Seleziona 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. 1. In **Configura test**, nella sezione **Seleziona framework di test**, scegli **Built-in: Fuzz**. 1. Se compare una delle impostazioni seguenti, è possibile accettare i valori predefiniti o specificare i propri: + **Conteggio eventi**: specificare un numero compreso tra 1 e 10.000, che rappresenta il numero di eventi di interfaccia utente che il test Fuzz deve eseguire. + **Event throttle**: specifica un numero compreso tra 0 e 1.000, che rappresenta il numero di millisecondi di attesa del fuzz test prima di eseguire il successivo evento dell'interfaccia utente. + **Seed randomizer**: specificare un numero che il test Fuzz utilizzerà per creare casualmente eventi di interfaccia utente. Se si specifica lo stesso numero per test Fuzz successivi, le sequenze di eventi saranno identiche. 1. Completa le istruzioni rimanenti per selezionare i dispositivi e avviare l'esecuzione.