Questa pagina è stata tradotta dall'API Cloud Translation.

Inizia a utilizzare i test di strumentazione

Questa guida descrive come preparare ed eseguire un test di strumentazione utilizzando Firebase Test Lab. Per utilizzare questa guida, ti serviranno test di strumentazione (scritto da te o dal tuo team) che utilizza il Espresso o UI Automator Framework di test Android. I test di strumentazione possono eseguire fino a 45 minuti su dispositivi fisici e fino a 60 minuti su dispositivi virtuali.

Nei passaggi successivi, devi caricare l'APK dell'app e l'APK del test a Firebase.

(Facoltativo) Aggiungere la raccolta di screenshot all'app

Firebase Test Lab include una libreria (testlab-instr-lib) che puoi per elaborare gli screenshot che acquisisci con AndroidX Acquisizione schermo quando si eseguono test di strumentazione, ad esempio test scritti utilizzando Framework di test Espresso. Questa sezione descrive come creare oggetti ScreenCapture con AndroidX e come elaborarle utilizzando testlab-instr-lib.

Dopo aver eseguito il test di misurazione, puoi visualizzare gli screenshot acquisiti nella console Firebase.

Prova un'app di esempio

Scarica l'app di esempio Notebooks. per provare questa funzionalità. La possibilità di acquisire screenshot è già incorporato nel progetto NotePad.

Passaggio 1: Aggiungi la raccolta di screenshot al progetto

Nel file Gradle delle impostazioni a livello principale del progetto di test (settings.gradle.kts o settings.gradle), aggiungi il Repository Maven di Google a ogni sezione repositories:

pluginManagement {
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
    }
}
// ...

Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi una dipendenza per Raccolta di screenshot di Test Lab.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

Nel file AndroidManifest.xml del test, registra il valore FirebaseScreenCaptureProcessor in un tag di metadati all'interno della Elemento <instrumentation>. Puoi anche specificare il processore come in AndroidJUnitRunner (vedi l'argomento Documentazione di riferimento AndroidJUnitRunner per istruzioni).

<instrumentation
  // Check that you have the following line (if not, add it):
  android:name="androidx.test.runner.AndroidJUnitRunner" // Specifies AndroidJUnitRunner as the test runner
  android:targetPackage="com.your.package.name">

// Add the following:
<meta-data
  android:name="screenCaptureProcessors"
  android:value="com.google.firebase.testlab.screenshot.FirebaseScreenCaptureProcessor" />
</instrumentation>
...

Nel file AndroidManifest.xml dell'app, aggiungi le seguenti righe all'interno della Elemento <manifest>:
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
Nel file AndroidManifest.xml, specifica le autorizzazioni di sistema per la tua app aggiungendo le seguenti righe all'interno del tag <manifest>. Se stai testando Su Android 10 (livello API 29) o versioni successive, ometti WRITE_EXTERNAL_STORAGE (la tua app non richiede questa autorizzazione per leggere e scrivi screenshot sul dispositivo).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Passaggio 2: Acquisire screenshot durante il test

In qualsiasi momento del test in cui vuoi acquisire uno screenshot, chiama il metodo Screenshot.capture() dalla raccolta AndroidX. Questo produce Oggetto ScreenCapture. Quando chiami process() sull'oggetto ScreenCapture, questo viene elaborato usando lo strumento Screen CaptureProcessor registrato nel tuo AndroidManifest.xml. Tieni presente che BasicScreenCaptureProcessor viene utilizzato se non sono registrati processori. Dato che hai registrato FirebaseScreenCaptureProcessor, i tuoi screenshot verrà elaborato tramite FirebaseScreenCaptureProcessor e sarà disponibile per te con i risultati quando esegui il test con Firebase Test Lab.

Esempi di casi d'uso per la creazione di un `ScreenCapture`:

Acquisisci uno screenshot completo su una build API.VERSION_CODES.JELLY_BEAN_MR2 e sopra:
```
Screenshot.capture()
```
Acquisisci un ScreenCapture dell'attività a qualsiasi livello API. Tieni presente che questa è l'unica opzione per i dispositivi precedenti a Build.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Casi d'uso di esempio per l'elaborazione di uno screenshot

Elabora un ScreenCapture tramite il FirebaseScreenCaptureProcessor:
```
Screenshot.capture().process();
```

Elabora ScreenCapture tramite un ScreenCaptureProcessor specificato (in questo modo puoi saltare la registrazione del processore):

Set<ScreenCaptureProcessor> processors = new HashSet<>();
processors.add(new FirebaseScreenCaptureProcessor());
Screenshot.capture().process(processors);

Imposta il nome e il formato del ScreenCapture ed elaboralo utilizzando il processore registrato:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Passaggio 3: Crea ed esegui il test

Sviluppa la tua app e testa gli APK (vedi Testare l'app per istruzioni).
Carica i file APK nella dashboard Test Lab della console Firebase.
Infine, esegui il test.

Passaggio 4: Visualizzare gli screenshot di test

Al termine del test, puoi visualizzare gli screenshot acquisiti nella console Firebase.

Nella scheda Test, seleziona il test completato. e poi fai clic sulla scheda Risultati.
Seleziona di nuovo il test e fai clic sulla scheda Screenshot che viene visualizzata.

(Facoltativo) Attivare funzionalità di test aggiuntive

Puoi abilitare le seguenti funzionalità nel test prima di eseguirlo con Test Lab:

Abilita Orchestrator

Android Test Orchestrator è uno strumento che esegue in modo indipendente i test di strumentazione della tua app. Test Lab utilizza sempre la versione più recente di Orchestrator.

Per abilitare Orchestrator per Test Lab, nel test di strumentazione configurazione, Fai clic su Opzioni aggiuntive > Esegui con Orchestrator.

Quando utilizzi Orchestrator, puoi sfruttare quanto segue:

Nessuno stato condiviso. Ogni test viene eseguito di strumentazione, in modo che lo stato condiviso non si accumuli nei test.
Arresti anomali isolati. Se un test si arresta in modo anomalo, la strumentazione viene terminata e gli altri test nella tua suite possono continuare a essere eseguiti.

Tieni presente che quando utilizzi Orchestrator, ogni test viene eseguito in modo indipendente di strumentazione, il che significa che il processo dell'app viene riavviato dopo in ogni scenario di test. L'aumento dei tempi di esecuzione potrebbe influire di utilizzo della quota o tempo fatturato e causare il superamento della soglia limiti di timeout. Se riduci il livello tempi di avvio, questo overhead si accorcierà.

Per impostare opzioni aggiuntive per Orchestrator, specificale tramite Campo environmentVariables: Ad esempio, per utilizzare clearPackageData, usa questo in gcloud:

--environment-variables clearPackageData=true

Abilita lo sharding

La suddivisione in blocchi dei test suddivide un insieme di test in sottogruppi (blocchi) che vengono eseguiti singolarmente in modo isolato. Test Lab esegue automaticamente ogni frammento in parallelo utilizzando più dispositivi e completa l'intero insieme di test in meno tempo.

Ad esempio, se crei N shard, per ogni dispositivo selezionato, Test Lab avvia N su dispositivi identici ed esegue un sottoinsieme di test su ciascuno. Ciò significa che gli scenari di test suddivisi in parti possono comportare più esecuzioni di test per dispositivo. Tuttavia, gli scenari di test non suddivisi in parti generano un'esecuzione del test per dispositivo. Per informazioni sui concetti di Test Lab, consulta Concetti chiave.

Per abilitare il test dello sharding nella console Firebase, segui questi passaggi:

Nella configurazione del test di strumentazione, fai clic su Opzioni aggiuntive.
Nella sezione Sharding, inserisci il numero di shard che vuoi eseguire.

Fatturazione per gli shard di test

Test Lab implementa gli shard sfruttando la tecnologia integrata di AndroidJUnitRunner meccanismo di sharding. Per evitare l'addebito per l'avvio di shard vuoti (shards senza assegnati scenari di test), il numero di shard che devono essere inferiori al numero totale di scenari di test. In base a come tempo necessario per l'esecuzione di ogni scenario di test, in genere è consigliabile assegnare 2-10 per shard.

Per ulteriori informazioni sulla fatturazione, leggi Utilizzo, quote e fatturazione.