Configura il tuo pacchetto di test Appium Crea un file di pacchetto compresso Esegui i tuoi test Appium Visualizza un rapporto di prova Acquisisci schermate dei tuoi test (opzionale)

Integrazione dei test Appium con Device Farm

Usa le seguenti istruzioni per integrare i test Appium con AWS Device Farm. Per ulteriori informazioni sull'utilizzo dei test Appium in Device Farm, consulta. Esegui automaticamente i test Appium in Device Farm

Configura il tuo pacchetto di test Appium

Utilizza le seguenti istruzioni per configurare il pacchetto del test.

Java (JUnit)

Modifica pom.xml per impostare la confezione su un file JAR:


<groupId>com.acme</groupId>
<artifactId>acme-myApp-appium</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

Modifica pom.xml da utilizzare 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:


<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <version>2.6</version>
  <executions>
    <execution>
      <goals>
        <goal>test-jar</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Modifica pom.xml da utilizzare per maven-dependency-plugin creare dipendenze come file JAR.

Il seguente plugin copia le tue dipendenze nella dependency-jars directory:


<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <version>2.10</version>
  <executions>
    <execution>
      <id>copy-dependencies</id>
      <phase>package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

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 nella directory: dependency-jars


<assembly
    xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>zip</id>
  <formats>
    <format>zip</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <fileSets>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory>./</outputDirectory>
      <includes>
        <include>*.jar</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory>./</outputDirectory>
      <includes>
        <include>/dependency-jars/</include>
      </includes>
    </fileSet>
  </fileSets>
</assembly>

Modifica pom.xml da utilizzare 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


<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.5.4</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <finalName>zip-with-dependencies</finalName>
        <appendAssemblyId>false</appendAssemblyId>
        <descriptors>
          <descriptor>src/main/assembly/zip.xml</descriptor>
        </descriptors>
      </configuration>
    </execution>
  </executions>
</plugin>

Nota

Se ricevi un messaggio di errore indicante che l'annotazione non è supportata nella versione 1.3, aggiungi quanto segue a pom.xml:


<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>

Java (TestNG)

Modifica pom.xml per impostare il packaging su un file JAR:


<groupId>com.acme</groupId>
<artifactId>acme-myApp-appium</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>

Modifica pom.xml da utilizzare 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:


<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <version>2.6</version>
  <executions>
    <execution>
      <goals>
        <goal>test-jar</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Modifica pom.xml da utilizzare per maven-dependency-plugin creare dipendenze come file JAR.

Il seguente plugin copia le dipendenze nella dependency-jars directory:


<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <version>2.10</version>
  <executions>
    <execution>
      <id>copy-dependencies</id>
      <phase>package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

Salvate il seguente assembly XML in. src/main/assembly/zip.xml


<assembly
    xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
  <id>zip</id>
  <formats>
    <format>zip</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <fileSets>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory>./</outputDirectory>
      <includes>
        <include>*.jar</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>${project.build.directory}</directory>
      <outputDirectory>./</outputDirectory>
      <includes>
        <include>/dependency-jars/</include>
      </includes>
    </fileSet>
  </fileSets>
</assembly>

Modifica pom.xml da utilizzare 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


<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <version>2.5.4</version>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <finalName>zip-with-dependencies</finalName>
        <appendAssemblyId>false</appendAssemblyId>
        <descriptors>
          <descriptor>src/main/assembly/zip.xml</descriptor>
        </descriptors>
      </configuration>
    </execution>
  </executions>
</plugin>

Nota

Se ricevi un messaggio di errore indicante che l'annotazione non è supportata nella versione 1.3, aggiungi quanto segue a pom.xml:


<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>

Node.JS

Per impacchettare i Node.js test Appium e caricarli su Device Farm, devi installare quanto segue sul tuo computer locale:

Node Version Manager (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)

Verificare che nvm sia presente
```
command -v nvm
```
Dovresti vedere nvm come output.

Per ulteriori informazioni, vedere https://github.com/nvm-sh/nvm nvm on. GitHub
Esegui questo comando per installare: Node.js
```
nvm install node
```
È possibile specificare una versione particolare di Node.js:
```
nvm install 11.4.0
```
Verificare che la versione corretta di Node sia in uso:
```
node -v
```
Installare npm-bundle globalmente:
```
npm install -g npm-bundle
```

Python

Si consiglia vivamente di configurare un virtualenv Python 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.
Installare py.test nell'ambiente virtuale.
```
$ pip install pytest
```
Installare il client Appium Python nell'ambiente virtuale.
```
$ pip install Appium-Python-Client
```
A meno che non si specifichi un percorso diverso in modalità personalizzata, Device Farm si aspetta che i test vengano archiviati intests/. È 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
```
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/
```
Verifica che l'output mostri i test che desideri eseguire su Device Farm.

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

Eseguire il comando seguente nell'area di lavoro, per generare il file requirements.txt:
```
$ pip freeze > requirements.txt
```

Ruby

Per impacchettare i test Appium Ruby e caricarli su Device Farm, devi installare quanto segue sul tuo computer locale:

Ruby Version Manager (RVM)

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

Installare le chiavi richieste, RVM e Ruby. Per istruzioni, consulta Installazione di RVM 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.
Verifica che rvm sia installato correttamente.
```
command -v rvm
```
Dovresti vedere rvm come output.
Se desideri installare una versione specifica di Ruby, ad esempio2.5.3, esegui il seguente comando:
```
rvm install ruby 2.5.3 --autolibs=0
```
Verificare di utilizzare la versione richiesta di Ruby:
```
ruby -v
```
Configura il bundler per compilare i pacchetti per le piattaforme di test desiderate:
```
bundle config specific_platform true
```
Aggiorna il tuo 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
```
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

Verifica il progetto.

Assicurati di essere nella directory principale del progetto. È possibile visualizzare package.json nella directory principale.
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.
Esegui il comando per creare pacchetti di file nella cartella corrente .tgz*. Il file è denominato utilizzando la proprietà name nel file package.json.
```
npm-bundle
```
Questo file tarball (.tgz) contiene tutti i codici e le dipendenze.
Esegui il comando per creare un bundle di tarball (* file.tgz) generato nel passo precedente in un singolo archivio compresso:
```
zip -r MyTests.zip *.tgz
```
Questo è il MyTests.zip file che caricherai 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

Esegui questo comando per creare un ambiente Ruby virtuale:


# myGemset is the name of your virtual Ruby environment
rvm gemset create myGemset

Esegui questo comando per utilizzare l'ambiente appena creato:
```
rvm gemset use myGemset
```
Consulta il codice sorgente.

Assicurati di essere nella directory principale del progetto. È possibile visualizzare Gemfile nella directory principale.
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
```

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

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 nella procedura seguente.

Esegui i tuoi test Appium

Puoi utilizzare la console Device Farm per caricare i tuoi test.

Accedi alla console Device Farm all'indirizzo https://console.aws.amazon.com/devicefarm.
Nel pannello di navigazione, scegli Mobile Device Testing, quindi scegli Progetti.
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.
Apri il progetto, quindi scegli Crea ed esegui.
In Seleziona app e tipo di esecuzione, nella sezione Tipo di esecuzione, seleziona il tipo di esecuzione. Seleziona l'app Android se stai testando un'app Android (formato di file.apk). Seleziona l'app iOS se stai testando un'app iOS (formato di file.ipa). Seleziona Web App se stai testando un'applicazione web mobile.
In Seleziona app, nella sezione Opzioni di selezione dell'app, scegli Seleziona un'app di esempio fornita da Device Farm se non hai un'app. Se stai portando la tua app, seleziona Carica la tua app. Quindi scegli il tuo APK (formato di file.apk) per Android o il tuo IPA (formato di file.ipa) per iOS. Se stai caricando un'app iOS, assicurati di scegliere un dispositivo iOS, non un simulatore.
In Configura test, nella sezione Seleziona il framework Appium con cui esegui il test, quindi seleziona Carica il tuo pacchetto di test. 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.
Puoi utilizzare le specifiche di test predefinite o scegliere Carica le tue specifiche di test per fornire le tue.
In Seleziona dispositivi, scegli un metodo di selezione dei dispositivi. Seleziona Usa pool di dispositivi per scegliere tra una raccolta curata di dispositivi o un pool di dispositivi personalizzato che hai creato. Seleziona Seleziona manualmente i dispositivi per scegliere i singoli dispositivi su cui eseguire i test. La sezione Compatibilità dei dispositivi mostra quanti dispositivi del pool selezionato sono compatibili con la tua app. Per ulteriori informazioni, consulta Supporto per i dispositivi in AWS Device Farm.
(Facoltativo) Per configurare le proprietà a livello di esecuzione, aggiorna la sezione Impostazioni di esecuzione:
- Device Farm attualmente supporta gli approfondimenti sui test solo per. Appium TestNG Per fare in modo che Device Farm generi un rapporto di test al termine dell'esecuzione, seleziona Genera rapporto di test. Questa opzione è disponibile solo in un ambiente di test personalizzato.
  
  Sono validi i seguenti prerequisiti:
  - I test devono generare un testng-results.xml file e scriverlo $DEVICEFARM_LOG_DIR su. Ad esempio, passate -d $DEVICEFARM_LOG_DIR/test-output al TestNG comando contenuto nel file delle specifiche di test. La specifica di TestNG test Appium Java predefinita produce e memorizza questo file automaticamente se si mantiene la configurazione predefinita.
Selezionare Confirm and start run (Controlla e avvia sessione). Per ulteriori informazioni, consulta Creazione di un'esecuzione di test in Device Farm.

Nota

Device Farm non modifica i test di Appium.

Visualizza un rapporto di prova

Al termine dell'esecuzione, Device Farm genera un rapporto di test per ogni dispositivo. Il rapporto mostra una suddivisione per test, che include il nome, la classe, il risultato e la durata di ciascun test, oltre a una traccia dello stack per ogni test fallito. Puoi visualizzare il rapporto di test nella console o recuperarlo tramite l'API.

Per aprire un processo completato nella console Device Farm:

Accedi alla console Device Farm all'indirizzo https://console.aws.amazon.com/devicefarm.
Nel pannello di navigazione, scegli Mobile Device Testing, quindi scegli Progetti.
Scegli il progetto che contiene l'esecuzione che desideri ispezionare.
Scegli la corsa completata per aprirne i dettagli.
Scegli uno dei lavori completati per aprire i risultati per quel dispositivo.

Ciò che vedi nei risultati del lavoro dipende dal framework di test e dal fatto che tu abbia abilitato test Insights. Scegli la scheda del framework per visualizzare i risultati.

Java (TestNG)

Con le informazioni sui test abilitate

I risultati del lavoro includono una scheda Rapporto di test. Sceglila per visualizzare una suddivisione per test. La schermata seguente mostra la scheda Rapporto di test.

La scheda Test report per un job Appium Java TestNG completato.

La scheda mostra i seguenti campi per ogni test:

testName: Il nome del metodo di test.
testClass: Il nome della classe di test.
result: Il risultato del test di Device Farm.
frameworkResult: Il risultato riportato da TestNG (PASS,FAIL, oSKIP). Device Farm associa questo valore al campo normalizzato. result
durationSeconds: La durata del test, in secondi.
startTimestamp: L'ora di inizio del test.
endTimestamp: L'ora in cui è terminato il test.
params: Per un test parametrizzato, i valori dei parametri che TestNG ha passato al test.
stackTrace: Per un test fallito, la traccia dello stack dell'errore.

Per scaricare il rapporto completo del test come file JSON, scegli Scarica il riepilogo completo nella parte superiore dei dettagli del lavoro.

Per scegliere quali colonne visualizzare, scegli l'icona a forma di ingranaggio. Nelle impostazioni, puoi selezionare le colonne da visualizzare e attivare o disattivare Raggruppa per classe. L'opzione Raggruppa per classe è attiva per impostazione predefinita e raggruppa i test in base alla classe di test. Disattivalo per visualizzare un elenco completo di tutti i test, come mostrato nella schermata seguente.

La scheda Rapporto di test con Raggruppa per classe è disattivata, mostrando un elenco semplice di test.

Senza che le informazioni sui test siano abilitate

I risultati del lavoro mostrano l'output e gli artefatti del test standard, ma nessuna scheda Rapporto di test. Per generare un rapporto di test, pianifica una nuova esecuzione con le informazioni sui test abilitate.

I risultati del lavoro per un job Appium Java TestNG completato senza le informazioni di test abilitate.

Visualizza un rapporto di prova ()AWS CLI

Esegui get-job e specifica l'ARN del lavoro:


aws devicefarm get-job --arn arn:aws:devicefarm:us-west-2:123456789012:job:PROJECT_ID/RUN_ID/00000

Se non hai abilitato test insights, la risposta contiene i campi standard del job, come lo stato del job, il risultato, i contatori e il dispositivo:


{
    "job": {
        "arn": "arn:aws:devicefarm:us-west-2:123456789012:job:EXAMPLE-PROJECT/EXAMPLE-RUN/00000",
        "name": "Example Android Phone",
        "created": "2026-07-31T16:58:20.000000-07:00",
        "status": "COMPLETED",
        "result": "FAILED",
        "counters": {
            "total": 3,
            "passed": 1,
            "failed": 1,
            "warned": 0,
            "errored": 0,
            "stopped": 0,
            "skipped": 1
        },
        "device": {
            "arn": "arn:aws:devicefarm:us-west-2::device:EXAMPLEDEVICEID",
            "name": "Example Android Phone",
            "platform": "ANDROID",
            "os": "14",
            "formFactor": "PHONE",
            "fleetType": "PUBLIC"
        },
        "deviceMinutes": {
            "total": 1.42,
            "metered": 0.0,
            "unmetered": 1.17
        },
        "videoCapture": true
    }
}

Se hai abilitato i test insights, la risposta include anche un insights oggetto. Questo oggetto contiene lo stato del rapporto di test, metriche di alto livello e un URL prefirmato al rapporto dettagliato:


{
    "job": {
        "arn": "arn:aws:devicefarm:us-west-2:123456789012:job:EXAMPLE-PROJECT/EXAMPLE-RUN/00000",
        "status": "COMPLETED",
        "result": "FAILED",
        "counters": { ... },
        "device": { ... },
        "deviceMinutes": { ... },
        "videoCapture": true,
        "insights": {
            "status": "COMPLETED",
            "testReport": {
                "message": "Results: 3 Executed | 1 passed, 1 failed, 1 skipped. Median test duration: 1.83 seconds.",
                "metrics": {
                    "testsTotal": 3,
                    "testsPassed": 1,
                    "testsFailed": 1,
                    "testsSkipped": 1,
                    "testsErrored": 0,
                    "testsOther": 0,
                    "testsPassedPercentage": 33.33
                },
                "testDetailsUrl": "https://EXAMPLE-PRESIGNED-URL"
            }
        }
    }
}

Il testDetailsUrl campo è un URL prefirmato del JSON completo del rapporto di test. Scaricalo per ottenere la suddivisione per test:


curl -o test-report.json "PRESIGNED_URL"

Di seguito è riportato un esempio di rapporto di test per un job Appium Java TestNG:


{
  "version": "1.0",
  "jobArn": "arn:aws:devicefarm:us-west-2:123456789012:job:EXAMPLE-PROJECT/EXAMPLE-RUN/00000",
  "deviceName": "Google Pixel 7",
  "deviceArn": "arn:aws:devicefarm:us-west-2::device:EXAMPLEDEVICEID",
  "deviceOsVersion": "14",
  "metrics": {
    "testsTotal": 3,
    "testsPassed": 1,
    "testsFailed": 1,
    "testsSkipped": 1,
    "testsErrored": 0,
    "testsOther": 0,
    "testsPassedPercentage": 33.33,
    "totalTestExecutionDurationSeconds": 5.421,
    "medianTestExecutionDurationSeconds": 1.83
  },
  "testDetails": [
    {
      "testName": "testValidLogin",
      "testClass": "com.example.app.LoginTest",
      "frameworkResult": "PASS",
      "result": "PASSED",
      "durationSeconds": 1.83,
      "startTimestamp": "2026-07-31T16:58:26.646000Z",
      "endTimestamp": "2026-07-31T16:58:28.476000Z"
    },
    {
      "testName": "testCheckout",
      "testClass": "com.example.app.CheckoutTest",
      "frameworkResult": "FAIL",
      "result": "FAILED",
      "durationSeconds": 3.102,
      "startTimestamp": "2026-07-31T16:58:28.500000Z",
      "endTimestamp": "2026-07-31T16:58:31.602000Z",
      "stackTrace": "java.lang.AssertionError: expected [true] but found [false]\n\tat org.testng.Assert.fail(Assert.java:99)\n\t...",
      "params": ["premium-user", "US"]
    },
    {
      "testName": "testLogout",
      "testClass": "com.example.app.LoginTest",
      "frameworkResult": "SKIP",
      "result": "SKIPPED",
      "durationSeconds": 0.489,
      "startTimestamp": "2026-07-31T16:58:31.700000Z",
      "endTimestamp": "2026-07-31T16:58:32.189000Z"
    }
  ]
}

Il rapporto contiene i seguenti campi di primo livello:

version

La versione dello schema del report.

jobArn

ARN del processo.

deviceName, deviceArn, deviceOsVersion

Il dispositivo su cui sono stati eseguiti i test e la relativa versione del sistema operativo.

metrics

Risultati aggregati per il lavoro. L'oggetto metrics include i seguenti campi:

testsTotal: Il numero totale di test del job.
testsPassed: Il numero di test superati.
testsFailed: Il numero di test che hanno avuto esito negativo.
testsSkipped: Il numero di test che sono stati saltati.
testsErrored: Il numero di test con errori.
testsOther: Il numero di test con un altro risultato.
testsPassedPercentage: La percentuale di test superati.
totalTestExecutionDurationSeconds: La durata totale di tutti i test, in secondi.
medianTestExecutionDurationSeconds: La durata mediana di un test, in secondi.

testDetails

Un elenco dei risultati per test. Ogni voce testDetails contiene i seguenti campi:

testName: Il nome del metodo di prova.
testClass: Il nome della classe di test.
result: Il risultato del test di Device Farm.
frameworkResult: Il risultato riportato da TestNG (PASS,FAIL, oSKIP). Device Farm associa questo valore al campo normalizzato. result
durationSeconds: La durata del test, in secondi.
startTimestamp: L'ora di inizio del test.
endTimestamp: L'ora in cui è terminato il test.
params: Per un test parametrizzato, i valori dei parametri che TestNG ha passato al test.
stackTrace: Per un test fallito, la traccia dello stack dell'errore.

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 viene 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 nella documentazione dell'API Appium.

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

Test Appium automatici

Test Android

Integrazione dei test Appium con Device Farm

Configura il tuo pacchetto di test Appium

Nota

Nota

Suggerimento

Nota

Crea un file di pacchetto di test compresso

avvertimento

Nota

Nota

Esegui i tuoi test Appium

Nota

Visualizza un rapporto di prova

Con le informazioni sui test abilitate

Senza che le informazioni sui test siano abilitate

Visualizza un rapporto di prova ()AWS CLI

Acquisisci schermate dei tuoi test (opzionale)