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à. # 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.