Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Eseguire la migrazione da Firebase Test Lab e Flank alla piattaforma di dispositivi per sviluppatori con l'AI

Questa skill aiuta a tradurre le configurazioni e i workflow di esecuzione dei test legacy (da Flank o gcloud firebase test) nella moderna interfaccia della CLI gcloud beta device-run orientata alle risorse (e gcloud alpha device-run per l'invio di sessioni XCTest per iOS).

Mappatura della struttura di comandi e risorse

La CLI Device Run organizza i comandi per risorsa: devices, software-versions e sessions:

1. Catalogo dei dispositivi (`devices`)

Elenco dei dispositivi:
- Legacy: gcloud firebase test android/ios models list
- Nuovo: gcloud beta device-run devices list [--filter="..."]
- Esempio: gcloud beta device-run devices list --filter="platform:android"
Descrivi il dispositivo:
- Legacy: gcloud firebase test android/ios models describe {MODEL}
- Nuovo: gcloud beta device-run devices describe {DEVICE}
- Esempio: gcloud beta device-run devices describe redfin-30
Controlla le capacità dei dispositivi e la disponibilità della flotta:
- Legacy: gcloud firebase test android/ios list-device-capacities
- Nuovo: incorporato direttamente nella risorsa Dispositivo (availability.capacity e availability.available). Controlla utilizzando gcloud beta device-run devices describe {DEVICE} o filtra direttamente con gcloud beta device-run devices list --filter="availability.capacity=CAPACITY_HIGH".

2. Versioni software (`software-versions`)

Elenca le versioni software supportate (Xcode e Android Test Orchestrator):
- Legacy: gcloud firebase test ios xcode-versions list
- Nuovo: gcloud beta device-run software-versions list
Descrivi la versione software:
- Nuovo: gcloud beta device-run software-versions describe {SOFTWARE_VERSION}
- Esempio: gcloud beta device-run software-versions describe xcode-16-4

3. Sessioni di automazione (`sessions`)

Invia strumentazione Android:
- Legacy: gcloud firebase test android run --type=instrumentation ...
- Nuovo: gcloud beta device-run sessions submit instrumentation ...
Invia XCTest per iOS:
- Legacy: gcloud firebase test ios run --type=xctest ...
- Nuovo: gcloud alpha device-run sessions submit xctest ...
Attendi il completamento della sessione:
- Legacy: solo blocco sincrono dell'interfaccia a riga di comando
- Nuovo: gcloud beta device-run sessions wait {SESSION}
Describe / Inspect Session (Descrivi/Ispeziona sessione):
- Legacy: visualizza il link web nella console Firebase / Cloud Tool Results
- Nuovo: gcloud beta device-run sessions describe {SESSION} [--full]
Elenco delle sessioni passate:
- Legacy: visualizza la cronologia della matrice nella console web
- Nuovo: gcloud beta device-run sessions list
Annulla sessione:
- Legacy: solo console web (nessun comando CLI)
- Nuovo: gcloud beta device-run sessions cancel {SESSION}

Tabella di riferimento per la mappatura dei flag

La seguente tabella mappa i parametri di Firebase Test Lab e Flank legacy ai loro equivalenti supportati in gcloud beta device-run:

Tipo di test	Gruppo di caratteristiche	Parametro precedente (firebase / Flank)	Parametro target (`device-run`)	Formato / Logica di conversione
Comuni (Android e iOS)	Parametri e asset principali	Lato `--project`	`--project`	Flag globale Google Cloud standard (`--project=PROJECT_ID`) o configurazione Google Cloud CLI attiva.
Comuni (Android e iOS)	Parametri e asset principali	`--client-details`	`--labels`	Dizionario di coppie chiave=valore.
Comuni (Android e iOS)	Configurazione e targeting del dispositivo	`--device model={M},version={V}`	`--device={M}-{V}`	Mappa il modello e la versione del sistema operativo alla stringa ID `--device`. Accetta un elenco separato da virgole di più dispositivi in un unico flag (ad es. `--device=mediumphone-arm-32,shiba-36`).
Comune (Android & iOS)	Controllo dell'esecuzione e instabilità	`--async`	`--async`	Maps 1:1. Il comando rimane sincrono per impostazione predefinita, passalo per restituire immediatamente. Monitora o attendi con `gcloud beta device-run sessions wait <SESSION_ID>`.
Comuni (Android e iOS)	Controllo dell'esecuzione e instabilità	`--num-flaky-test-attempts {R}`	`--flaky-test-attempts {A}`	Numero intero. Converti il conteggio dei tentativi $R$ nel limite totale di tentativi: $A = R + 1$ (il valore predefinito è 1).
Comuni (Android e iOS)	Controllo dell'esecuzione e instabilità	N/D	`--flaky-test-parallel-retry`	Boolean. Indica se ritentare i test non riusciti in parallelo (il valore predefinito è sequenziale).
Comuni (Android e iOS)	Controllo dell'esecuzione e instabilità	N/D	`--flaky-test-retry-level`	Stringa. Livello di nuovo tentativo: `shard` o `test` (il valore predefinito è `shard`).
Comune (Android & iOS)	Output e archiviazione	`--results-bucket`	`--bucket-name`	Bucket in cui vengono caricati gli artefatti di output del test (il valore predefinito è `gs://[PROJECT_ID]-devicerun`).
Comune (Android & iOS)	Output e archiviazione	`--results-dir`	Gestito automaticamente	L'impostazione di sottodirectory personalizzate non è supportata; tutti gli artefatti di test vengono organizzati automaticamente in `automation/sessions/{session_id}/` all'interno del bucket specificato da `--bucket-name`.
Comuni (Android e iOS)	Output e archiviazione	`--record-video`	`--video`	Valori validi: `always` o `on-failure`.
Comune (Android & iOS)	Output e archiviazione	`--directories-to-pull`	`--paths-to-pull`	Elenco di percorsi da estrarre dal dispositivo dopo l'esecuzione.
Android comune	Parametri e asset principali	`--app`	`--apps`	Elenco. Se vengono forniti più APK/AAB dell'applicazione, passali tutti a `--apps`.
Android comune	Parametri e asset principali	`--additional-apks`	`--apps`	Elenco. Unisci i valori degli elenchi aggiuntivi direttamente nell'elenco `--apps` principale.
Android comune	Parametri e asset principali	`--obb-files`	`--other-files-to-push`	Dizionario in formato `SOURCE=DEST`. Trasferisci i file OBB direttamente al percorso del dispositivo (`/sdcard/Android/obb/{package_name}/`).
Android comune	Parametri e asset principali	`--other-files`	`--other-files-to-push`	Dizionario in formato `SOURCE=DEST`.
Android comune	Configurazione e targeting dei dispositivi	`--device locale={L}`	`--locale={L}`	Mappa le impostazioni internazionali del dispositivo `--locale` al flag di primo livello (`language-region`, ad es. `--locale=en-US`).
Android comune	Configurazione e targeting dei dispositivi	`--device orientation={O}`	`--orientation={O}`	Mappa l'orientamento del dispositivo al flag `--orientation` di primo livello (`portrait` o `landscape`).
Android comune	Configurazione e targeting dei dispositivi	N/D	`--coordinates`	Coordinate della posizione fittizia (`latitude,longitude`, ad es. `37.4220,-122.0841`).
Android comune	Controllo dell'esecuzione e instabilità	`--grant-permissions`	Impostazione predefinita automatizzata	Automated. Le autorizzazioni di runtime vengono concesse automaticamente per impostazione predefinita (equivalente a `--grant-permissions=all`).\|
Android comune	Output e archiviazione	N/D	`--dumpsys`	Raccogli dumpsys dal dispositivo (`always` o `on-failure`).
Android comune	Output e archiviazione	N/D	`--bugreport`	Raccogli la segnalazione di bug dal dispositivo (`always` o `on-failure`).
Strumentazione Android	Parametri e asset principali	`--type=instrumentation`	`sessions submit instrumentation`	La struttura del sottocomando determina il tipo di test anziché un flag `--type`.
Android Instrumentation	Parametri e asset principali	`--test`	`--test`	Percorso del file binario contenente i test di instrumentazione.
Strumentazione Android	Controllo dell'esecuzione e instabilità	`--timeout`	`--instrumentation-timeout`	Durata (ad es. `10m`, `20s`, `1h`). Intervallo valido: da `1m` a `3h` (valore predefinito: `5m`).
Android Instrumentation	Controllo dell'esecuzione e instabilità	`--num-uniform-shards {N}`	`--sharding-option=uniform` `--uniform-sharding-count={N}`	La configurazione del flag attiva la strategia di sharding uniforme (intervallo di conteggio valido: 1-20 fisici, 1-200 virtuali).
Strumentazione Android	Controllo dell'esecuzione e instabilità	Fianco `--shard-time {S}`	`--sharding-option=smart` `--smart-sharding-target-duration={S}`	Attiva lo sharding intelligente con il tempo di esecuzione target (ad es. `2m`, `10m`, `1h`). Intervallo valido: da `2m` a `1h`.
Strumentazione Android	Controllo dell'esecuzione e instabilità	Fianco `--smart-flank-gcs-path`	`--smart-sharding-record-name={name}` `--bucket-name={bucket}`	Nome del file YAML del record di sharding (escludi l'estensione) all'interno di `--bucket-name` in `automation/smart-sharding/`.
Strumentazione Android	Controllo dell'esecuzione e instabilità	Fianco `--max-test-shards {N}`	`--smart-sharding-max-shard-count={N}`	Esegue la mappatura a un limite massimo di shard quando lo sharding smart è abilitato (0-20 fisici, 0-200 virtuali).
Strumentazione Android	Test runner e target	`--test-runner-class`	`--test-runner-class`	Classe runner completa.
Strumentazione Android	Test runner e target	`--test-targets`	`--test-targets`	Dizionario che supporta chiavi come `package`, `notPackage`, `class`, `notClass`, `annotation`, `notAnnotation` e `size`. I formati come `testfile` o `notTestfile` non saranno supportati.
Android Instrumentation	Test runner e target	`--use-orchestrator`	`--orchestrator-version`	Accetta `auto` (orchestratore predefinito) o una stringa di versione specifica (ad es. `1.6`).
Android Instrumentation	Test runner e target	`--environment-variables`	`--additional-test-options`	Dizionario di opzioni passate all'esecutore di test. I formati supportati in `--test-targets` non sono consentiti qui.
iOS comuni	Parametri e asset principali	`--additional-ipas`	`--additional-apps`	Elenco di file `.ipa` da installare sul dispositivo prima dell'esecuzione del test.
iOS comune	Parametri e asset principali	`--other-files`	`--other-files-to-push`	Dizionario in formato `SOURCE=BUNDLE_ID:DEVICE_PATH`.
iOS comune	Configurazione e targeting del dispositivo	`--device locale={L}`	`--locale={L}`	Mappa le impostazioni internazionali del dispositivo al flag `--locale` di primo livello (`language-region`, ad es. `--locale=en-US`).
iOS comuni	Output e archiviazione	`--directories-to-pull`	`--paths-to-pull`	Elenco di file o directory da estrarre dopo il test nel formato `BUNDLE_ID:DEVICE_PATH`.
Solo XCTest per iOS	Parametri e asset principali	`--type=xctest`	`sessions submit xctest`	La struttura dei sottocomandi determina il tipo di test anziché un flag `--type` (utilizza `gcloud alpha`).
Solo XCTest per iOS	Parametri e asset principali	`--test`	`--test`	Il percorso del file ZIP contenente l'app per iOS e i file XCTest.
Solo XCTest per iOS	Controllo dell'esecuzione e instabilità	`--timeout`	`--xctest-timeout`	Durata massima consentita per l'esecuzione di XCTest (intervallo valido: da `1m` a `1h`, valore predefinito: `5m`).
Solo XCTest per iOS	Test runner e target	`--xctestrun-file`	`--xctestrun-file`	Il percorso del file .xctestrun personalizzato.
Solo XCTest per iOS	Test runner e target	`--xcode-version`	`--xcode-version`	ID catalogo o stringa della versione di Xcode da utilizzare (ad es. `xcode-16-4` o `16.4`). Query using `software-versions list`.

Indicazioni utili per la traduzione

Segui queste linee guida per convertire le configurazioni di Firebase Test Lab e Flank in esecuzione sul dispositivo:

1. Specifiche dei dispositivi

In gcloud beta device-run, --device accetta un elenco separato da virgole di stringhe di ID modello e versione. A differenza di Firebase, che richiedeva un flag --device per dispositivo, device-run consente di specificare più dispositivi in un unico flag. La lingua, l'orientamento e le coordinate simulate del dispositivo vengono specificati utilizzando flag di primo livello separati:

❌ --device model=MediumPhone.arm,version=32,locale=en,orientation=portrait
✅ --device=mediumphone-arm-32 --locale=en-US --orientation=portrait

2. Dizionari ed elenchi

Converti i flag separati da virgole in elenchi (--apps, --paths-to-pull) o dizionari chiave-valore (--other-files-to-push, --additional-test-options):

❌ --other-files /sdcard/file1.txt=local/file1.txt,/sdcard/file2.txt=local/file2.txt
✅ --other-files-to-push local/file1.txt=/sdcard/file1.txt,local/file2.txt=/sdcard/file2.txt

3. Strategie di sharding

Uniform Sharding:
- Imposta --sharding-option=uniform.
- Imposta --uniform-sharding-count={count} (1-20 per i prodotti fisici, 1-200 per quelli virtuali).
Smart Sharding:
- Imposta --sharding-option=smart.
- Imposta --smart-sharding-target-duration={duration} (ad es. 2m, 10m, 1h; intervallo valido: da 2m a 1h).
- Imposta --smart-sharding-record-name={record_name} (punta al record di monitoraggio YAML all'interno di --bucket-name in automation/smart-sharding/).
- Imposta --smart-sharding-max-shard-count={max_count} (limite massimo facoltativo: 0-20 per le attività fisiche, 0-200 per quelle virtuali).

4. Esecuzione asincrona

Async & Waiting: quando viene specificato --async, l'interfaccia a riga di comando restituisce immediatamente l'ID sessione creato. Puoi attendere il completamento della sessione nei workflow CI/CD utilizzando: gcloud beta device-run sessions wait <SESSION_ID>

5. Configurazione YAML dichiarativa (`--flags-file`)

Per configurazioni complesse o team che preferiscono gestire file con controllo della versione anziché lunghi comandi del terminale, gcloud fornisce un preprocessor di argomenti --flags-file universale (vedi $ gcloud topic flags-file):

gcloud beta device-run sessions submit instrumentation --flags-file=device-run-flags.yaml

!NOTA Perché le chiavi richiedono --: gcloud inserisce le chiavi YAML direttamente nel parser CLI come flag della riga di comando. Ogni chiave nel file YAML deve avere il prefisso -- (ad es. --device:, --apps:). Senza --, gcloud li rifiuta come argomenti posizionali non riconosciuti.

Ecco un esempio che mostra i flag di elenco e dizionario con più valori:

# device-run-flags.yaml
--device:
  -   mediumphone-arm-32
  -   shiba-36
--apps:
  -   app-debug.apk
  -   test-helper.apk
--test: app-debug-androidTest.apk
--bucket-name: my-bucket
--sharding-option: smart
--smart-sharding-target-duration: 2m
--smart-sharding-record-name: timing-record
--paths-to-pull:
  -   /sdcard/screenshots
  -   /sdcard/coverage.ec
--additional-test-options:
  coverage: "true"
  clearPackageData: "true"

Traduzioni di esempio

Utilizza questi esempi per tradurre le configurazioni esistenti di Firebase Test Lab e Flank in Device Run.

Firebase Test Lab to device-run

firebase cmd:

gcloud firebase test android run \
  --app=app-debug.apk \
  --test=app-debug-androidTest.apk \
  --device model=shiba,version=36 \
  --timeout=5m \
  --num-flaky-test-attempts=2 \
  --directories-to-pull=/sdcard/screenshots \
  --environment-variables coverage=true

Traduzione:

gcloud beta device-run sessions submit instrumentation \
  --device=shiba-36 \
  --apps=app-debug.apk \
  --test=app-debug-androidTest.apk \
  --instrumentation-timeout=5m \
  --flaky-test-attempts=3 \
  --paths-to-pull=/sdcard/screenshots \
  --additional-test-options coverage=true

Configurazioni Flank per l'esecuzione del dispositivo

flank options (flank.yml):

gcloud:
  app: app-debug.apk
  test: app-debug-androidTest.apk
  device:
    -   model: mediumphone-arm
      version: 32
  shard-time: 120
  smart-flank-gcs-path: gs://my-bucket/automation/smart-sharding/timing-record.yaml

Traduzione:

Opzione 1: chiamata diretta della CLI (consigliata)

Traduci direttamente nel comando CLI moderno:

gcloud beta device-run sessions submit instrumentation \
  --device=mediumphone-arm-32 \
  --apps=app-debug.apk \
  --test=app-debug-androidTest.apk \
  --bucket-name=my-bucket \
  --sharding-option=smart \
  --smart-sharding-target-duration=2m \
  --smart-sharding-record-name=timing-record

Opzione 2: file di flag YAML dichiarativo (`--flags-file`)

Se preferisci gestire le configurazioni in un file YAML con controllo della versione anziché in stringhe di script shell, utilizza la funzionalità --flags-file integrata di gcloud:

# device-run-flags.yaml
# Note: gcloud requires keys to start with '--'
--device:
  -   mediumphone-arm-32
--apps:
  -   app-debug.apk
--test: app-debug-androidTest.apk
--bucket-name: my-bucket
--sharding-option: smart
--smart-sharding-target-duration: 2m
--smart-sharding-record-name: timing-record

Invia con l'interfaccia a riga di comando:

gcloud beta device-run sessions submit instrumentation --flags-file=device-run-flags.yaml

(Puoi anche aggiungere o eseguire l'override dei flag sulla riga di comando, ad esempio aggiungendo --async).

Device Catalog Discovery

listing & inspecting devices:

# List all available Android devices
gcloud beta device-run devices list --filter="platform:android"

# Filter devices with high fleet capacity (replaces legacy list-device-capacities)
gcloud beta device-run devices list --filter="availability.capacity=CAPACITY_HIGH"

# Describe a specific device (OS versions, form factors, orientation, locales, capacity)
gcloud beta device-run devices describe redfin-30

Ciclo di vita della sessione end-to-end in CI/CD

submitting, waiting, and inspecting sessions:

# 1. Submit asynchronously and capture session ID
SESSION_ID=$(gcloud beta device-run sessions submit instrumentation \
  --apps=app-debug.apk \
  --test=app-debug-androidTest.apk \
  --device=mediumphone-arm-32 \
  --async \
  --format="value(name)")

# 2. Wait for session completion in CI/CD pipeline
gcloud beta device-run sessions wait "$SESSION_ID"

# 3. Describe session summary (or pass --full for complete details)
gcloud beta device-run sessions describe "$SESSION_ID"

# 4. Cancel a running session if aborted
gcloud beta device-run sessions cancel "$SESSION_ID"