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 competenza aiuta a tradurre le configurazioni e i workflow di esecuzione dei test legacy (da Flank o gcloud firebase test) nella moderna interfaccia a riga di comando gcloud beta device-run orientata alle risorse.

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

Elenca 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 del 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 ...
Submit iOS XCTest:
- Legacy: gcloud firebase test ios run --type=xctest ...
- Nuovo: gcloud beta device-run sessions submit xctest ...
Attendi il completamento della sessione:
- Legacy: solo blocco sincrono della CLI
- Nuovo: gcloud beta device-run sessions wait {SESSION}
Descrivi / Ispeziona sessione:
- Legacy: visualizza il link web nella console Firebase / nei risultati di Cloud Tool
- Nuovo: gcloud beta device-run sessions describe {SESSION} [--full]
List Past Sessions:
- 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`)	Logica di formato / conversione
Comune (Android & iOS)	Parametri e asset principali	Fianco `--project`	`--project`	Flag globale standard Google Cloud (`--project=PROJECT_ID`) o configurazione Google Cloud CLI attiva.
Comune (Android & iOS)	Parametri e asset principali	`--client-details`	`--labels`	Dizionario di coppie chiave=valore.
Comune (Android & 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>`.
Comune (Android & 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).
Comune (Android & iOS)	Controllo dell'esecuzione e instabilità	N/D	`--flaky-test-parallel-retry`	Booleano. Indica se riprovare i test non riusciti in parallelo (il valore predefinito è sequenziale).
Comune (Android & iOS)	Controllo dell'esecuzione e instabilità	N/D	`--flaky-test-retry-level`	Stringa. Livello di riprova: `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`.
Comune (Android & 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 dei 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 aggiuntivi dell'elenco direttamente nell'elenco principale `--apps`.
Android comune	Parametri e asset principali	`--obb-files`	`--other-files-to-push`	Dizionario nel 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 nel formato `SOURCE=DEST`.
Android comune	Configurazione e targeting del dispositivo	`--device locale={L}`	`--locale={L}`	Mappa le impostazioni internazionali del dispositivo con il flag di primo livello `--locale` (`language-region`, ad es. `--locale=en-US`).
Android comune	Configurazione e targeting del dispositivo	`--device orientation={O}`	`--orientation={O}`	Mappa l'orientamento del dispositivo al flag di primo livello `--orientation` (`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`	Automated Default	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`).
Android Instrumentation	Parametri e asset principali	`--type=instrumentation`	`sessions submit instrumentation`	La struttura dei sottocomandi 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 strumentazione.
Android Instrumentation	Controllo dell'esecuzione e instabilità	`--timeout`	`--instrumentation-timeout`	Durata (ad es. `10m`, `20s`, `1h`). Intervallo valido: da `1m` a `3h` (il 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 una strategia di sharding uniforme (intervallo di conteggio valido: 1-20 fisici, 1-200 virtuali).
Android Instrumentation	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`.
Android Instrumentation	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/`.
Android Instrumentation	Controllo dell'esecuzione e instabilità	Fianco `--max-test-shards {N}`	`--smart-sharding-max-shard-count={N}`	Mappa a un limite massimo di shard quando è abilitato lo sharding intelligente (0-20 fisici, 0-200 virtuali).
Android Instrumentation	Test runner e target	`--test-runner-class`	`--test-runner-class`	Classe runner completa.
Android Instrumentation	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 al test runner. I formati supportati in `--test-targets` non sono consentiti qui.
iOS comune	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	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`.
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 di versione di Xcode da utilizzare (ad es. `xcode-16-4` o `16.4`). Query using `software-versions list`.

Indicazioni pratiche per la traduzione

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

1. Specifiche del dispositivo

In gcloud beta device-run, --device accetta un elenco separato da virgole di stringhe ID modello e versione. A differenza di Firebase, che richiedeva un flag --device per dispositivo, l'esecuzione sui dispositivi consente di specificare più dispositivi in un unico flag. La località, 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

Sharding uniforme:
- Imposta --sharding-option=uniform.
- Imposta --uniform-sharding-count={count} (1-20 per le sedi fisiche, 1-200 per quelle 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, la CLI restituisce immediatamente l'ID sessione creato. Puoi attendere il completamento della sessione nei flussi di lavoro 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 elenchi e dizionari multivalore:

# 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 convertire le configurazioni esistenti di Firebase Test Lab e Flank in esecuzioni sui dispositivi.

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

Tradotto in:

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 di test di integrazione per l'esecuzione sul 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

Tradotto in:

Opzione 1: invocazione 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 dichiarativi (`--flags-file`)

Se preferisci gestire le configurazioni in un file YAML con controllo delle versioni 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 sostituire i flag nella riga di comando, ad esempio aggiungendo --async).

Rilevamento del catalogo dei dispositivi

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 end-to-end della sessione 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"