Test di automazione iOS con Xcode Framework dell'interfaccia utente

By: Tommaso Hamilton Tommaso Hamilton
Hours aggiornato

⚡ Riepilogo intelligente

Test di automazione iOS con Xcode Registra e riproduce le azioni dell'interfaccia utente su un'applicazione in fase di test, seguendo un ciclo di test-driven che prevede progettazione, test, implementazione e un nuovo test fino a quando ogni caso non viene superato.

  • 🔘 Ciclo TDD: Progettazione, test, implementazione e ulteriore test: queste sono le quattro fasi applicate al collaudo delle applicazioni iOS.
  • ☑️ Prerequisiti: Un Mac con sistema operativo OS X e Xcode IDE, framework di automazione e SDK iOS installati.
  • ✅ Percorso degli strumenti: Lo strumento di automazione registra uno script, lo visualizza nel registro degli script e lo riproduce su richiesta.
  • 🧪 Percorso OCUnit: Un target Unit Test Bundle, uno schema attivo, un gruppo di test e una classe di test scritti in Objective-C.
  • ⚠️ Deprecazione: Lo strumento UIAutomation è stato deprecato in Xcode 8 e rimosso; XCUITest è il successore supportato.
  • ️ Equivalente moderno: Un target UI Testing Bundle con query XCUIApplication sostituisce lo script Instruments registrato.
Scopri di più

Test di automazione iOS con il Xcode Framework di automazione dell'interfaccia utente che esegue uno script registrato su un'app

Test di automazione iOS utilizzando Xcode

Per garantire la qualità della tua applicazione iOS, dovresti seguire il processo di sviluppo guidato dai test (TDD) illustrato nella figura seguente.

Ciclo di sviluppo guidato dai test per l'automazione dei test iOS, che mostra le fasi di progettazione, test, implementazione e ritest.

Lo sviluppo guidato dai test (TDD) è un analisi modello che viene applicato al test delle applicazioni iOS e si colloca all'interno della pratica più ampia di test mobileIn questo modello, un tester deve seguire le 4 fasi seguenti:

  • Design: Definisci cosa vuoi testare e progetta i tuoi casi di test.
  • Test: Esegui tutti i test e verifica se qualcuno di essi fallisce.
  • Strumento: RevUsa il tuo codice e correggi i bug che hanno causato il fallimento del test.
  • Prova di nuovo: Se un test fallisce, ripristinare la progettazione originale. Se tutti i casi di test vengono superati, il codice soddisfa tutti i requisiti testati.

Impostare Xcode Progetto per il test dell'interfaccia utente

Per creare un programma di test per iOS è necessario un Mac. Il Mac deve già avere installati i seguenti programmi:

  • OS X — il sistema operativo per un Mac.
  • Xcode IDE — lo strumento di sviluppo per iOS.
  • Un framework di test automatizzato — Automazione dell'interfaccia utente, OCUnit e così via.
  • iOS SDK 4 o superiore.

⚠️ Nota sulla versione: I prerequisiti sopra descritti illustrano la toolchain dell'epoca in cui sono state scritte le due guide che seguono. Su un Mac attuale, Xcode Il pacchetto include i framework XCTest e XCUITest, mentre lo strumento separato di automazione dell'interfaccia utente non è più incluso nell'installazione. I passaggi originali sono conservati di seguito perché documentano il funzionamento del framework, mentre la procedura equivalente moderna è descritta più avanti.

Come creare l'automazione iOS utilizzando UI Automation Framework

Gli otto passaggi seguenti consentono di registrare uno script con lo strumento di automazione e di riprodurlo sull'applicazione in fase di test.

Passaggio 1) Avviare Strumenti

Apri XCode -> Apri Strumento per sviluppatori -> Strumento

Strumenti di apertura dal Xcode Apri il menu Strumenti per sviluppatori

Passaggio 2) Aggiungi lo strumento di automazione

Nella finestra Strumenti, selezionare lo strumento Automazione.

Selezione dello strumento di automazione nel selettore del modello Strumenti

Per creare uno script di test, è necessario registrare un scenario di prova oppure lo si programma manualmente.

Passaggio 3) Premere il pulsante rosso

Si sta avviando uno strumento: interrompi immediatamente la registrazione. Se desideri avviare la registrazione, premi il pulsante rosso.

Pulsante di registrazione rosso nella barra degli strumenti Strumenti utilizzato per avviare e interrompere una registrazione trace

Passaggio 4) Crea un nuovo script

Nella finestra Script, fai clic su Aggiungi > Crea per creare un nuovo script.

Nella finestra Script di Instruments è presente il menu Aggiungi e crea per un nuovo script di automazione.

Passaggio 5) Scegli il bersaglio

Ora ti trovi nel Trace finestra. Usa Scegli Target Seleziona la versione di debug della tua app tramite il menu a tendina.

Scegli Target menu a tendina negli Strumenti Trace la finestra che punta alla build di debug

In questo caso, il campione di Apple SempliceDrillDown L'app viene utilizzata come applicazione da testare. Ha l'interfaccia grafica mostrata di seguito.

L'interfaccia dell'applicazione di esempio SimpleDrillDown viene utilizzata come applicazione da testare.

Passaggio 6) Inizia a registrare il tuo script

Registra il tuo script premendo il pulsante di registrazione nella parte superiore o inferiore dello strumento.

Pulsante di registrazione sul bordo della finestra Strumenti che avvia l'acquisizione dello script

Ora puoi eseguire alcune azioni sull'interfaccia utente dell'applicazione in fase di test e il tuo script verrà registrato.

Passaggio 7) Visualizza il tuo script

Per vedere la tua sceneggiatura, premi il pulsante TracSeleziona il menu a tendina Log / Editor Log e passa alla visualizzazione del registro dello script.

TracIl menu a tendina "e Log" e "Editor Log" viene utilizzato per passare alla visualizzazione del registro dello script.

Vedrai il tuo script registrato.

Script di automazione dell'interfaccia utente registrato, visualizzato nella vista del registro degli script di Instruments.

Passaggio 8) Riproduci la tua sceneggiatura

Premi il pulsante di riproduzione. Lo script verrà eseguito e potrai interromperlo dopo la visualizzazione dei log.

Riproduzione dello script di automazione registrato con output di log nella finestra Strumenti.

⚠️ Nota storica: Lo strumento di automazione utilizzato in questi otto passaggi è stato deprecato in Xcode 8 e successivamente rimosso, quindi non è più presente nella versione attuale Xcode installazioni. I passaggi sono conservati qui come documentazione del funzionamento del framework; per nuove installazioni, utilizzare la procedura guidata XCUITest più in basso in questa pagina.

ARTICOLI CORRELATI

Come creare l'automazione iOS utilizzando il framework OCUnit

Il secondo percorso colloca i test all'interno del Xcode il progetto stesso piuttosto che all'interno di Instruments.

Passaggio 1) Inizia Xcode IDE, Aggiungi destinazione Unit Test Bundle

Aggiunta di un target Unit Test Bundle a un progetto esistente Xcode progetto

Passaggio 2) Scrivere il nome del nuovo Unit Test Bundle come mostrato nella figura sopra, quindi fare clic su Fine.

Passaggio 3) Eseguire il test unitario del target attivo

Selezionando il bundle di test unitari come destinazione attiva in Xcode

Passaggio 4) Aggiungere un gruppo per le classi di prova

Creazione di un gruppo di progetto per contenere le classi di test unitari iOS

Passaggio 5) Aggiungere una classe di test unitario

Aggiunta di un nuovo file di classe di test unitario all'interno del gruppo di test in Xcode

Passaggio 6) Ora inizia l'implementazione

Classe di test unitario vuota nel Xcode editor pronto per l'implementazione di prova

OCUnit utilizza il linguaggio Objective-C per creare il programma di test, quindi lo sviluppatore deve conoscere tale linguaggio. Moderno Xcode versioni spedite unit test tramite XCTest invece, che supporta sia Objective-C che Swift, ma la struttura target-classe mostrata in questi sei passaggi rimane invariata.

UIAutomation vs XCUITest: cosa è cambiato?

Poiché entrambi i framework sopra menzionati appartengono a una generazione precedente della toolchain di Apple, è opportuno precisare cosa li ha sostituiti e perché.

Aspetto Automazione dell'interfaccia utente (strumenti) XCUITest
Stato Deprecato in Xcode 8 e rimosso dalle versioni successive Framework di test dell'interfaccia utente supportato da Apple
Dove vivono i test Script all'interno di uno strumento tracdocumento elettronico Un target UI Testing Bundle all'interno del Xcode progetto
Lingue disponibili JavaCopione Swift o Objective-C
Corridore di prova Lo strumento di automazione XCTest, lo stesso runner dei test unitari
Integrazione continua Imbarazzante — guidato attraverso gli strumenti Esegue da riga di comando insieme ai test unitari
Registrazione Pulsante Registra nella barra degli strumenti Strumenti pulsante Registra nel Xcode editore, che emette Swift

La conseguenza pratica è che una suite XCUITest è un normale codice sorgente di progetto. Viene revisionata, versionata ed eseguita come il resto del codice sorgente, che è il motivo principale per cui il codice registratotrace il modello è scomparso.

Come scrivere un test dell'interfaccia utente iOS con XCUITest

L'equivalente moderno degli otto passaggi di Instruments è breve. La struttura sottostante rispecchia la stessa idea di registrazione e successiva riproduzione, ma l'output è un file sorgente anziché un trace.

  1. Aggiungi il bersaglio. In Xcode scegli File > Nuovo > Target e selezionare il modello UI Testing Bundle oppure spuntare l'opzione per includere i test durante la creazione di un nuovo progetto.
  2. Apri la classe di test generata. Xcode crea una sottoclasse di XCTestCase con metodi di configurazione e test vuoti.
  3. Avviare l'applicazione in fase di test. Crea un'istanza di XCUIApplication e chiama il metodo launch su di essa, che avvia l'applicazione in un processo separato.
  4. Interrogare e agire. È possibile accedere agli elementi tramite le query degli elementi (pulsanti, tabelle, testi statici) e richiamare le funzioni tap, typeText o swipe su di essi.
  5. Affermazione. Utilizzare XCTAssert per verificare che l'elemento previsto esista dopo l'azione.
  6. Correre. Eseguire il test dal Xcode test navigator, oppure dalla riga di comando in modo che la stessa suite venga eseguita in integrazione continua.

Un test minimo segue questa forma:

import XCTest

final class AppUITests: XCTestCase {

    func testTappingFirstRowShowsDetail() {
        let app = XCUIApplication()
        app.launch()

        // act on the first row of the list
        app.tables.cells.element(boundBy: 0).tap()

        // verify that the next screen appeared
        XCTAssertTrue(app.staticTexts.firstMatch.waitForExistence(timeout: 5))
    }
}

Il registratore esiste ancora: posizionando il cursore all'interno di un metodo di test e premendo il pulsante di registrazione nell'editor, queste query vengono generate automaticamente, il che è il diretto discendente del passaggio 6 sopra. I principi più ampi di test di automazione applicare senza modifiche.

Esempio di automazione dell'interfaccia utente Code

Questo articolo include alcuni esempi di codice sorgente. Ti aiuteranno a comprendere il tutorial in modo più chiaro e rapido.

Esempio di automazione dell'interfaccia utente — script di test per la demo di automazione dell'interfaccia utente.

DOMANDE FREQUENTI

No. Xcode e i simulatori iOS funzionano solo su macOSPertanto, è necessario un Mac, sia in locale che come macchina di build ospitata. I data center cloud e i provider di CI ospitata esistono proprio per consentire ai team sprovvisti di hardware Mac di eseguire comunque la suite.

I modelli di apprendimento automatico suggeriscono query di sostituzione degli elementi quando cambia la schermata, raggruppano i malfunzionamenti intermittenti in base alla causa principale e classificano quali esecuzioni fallite rappresentano vere e proprie regressioni. Questo è importante per le suite di interfacce utente, dove piccole modifiche al layout potrebbero altrimenti compromettere molti selettori contemporaneamente.

Gestisce bene le parti ripetitive: la generazione automatica delle classi di test, gli argomenti di avvio, i wrapper degli oggetti pagina e il codice standard per le asserzioni. Gli identificatori degli elementi devono comunque corrispondere all'applicazione reale, quindi ogni query generata necessita di essere verificata rispetto alla build in esecuzione prima di essere considerata attendibile.

Appium guida iOS tramite il suo driver XCUITest, che ha sostituito il vecchio driver UIAutomation. Il vantaggio è un linguaggio di test multipiattaforma per iOS e AndroidIl compromesso consiste in un ulteriore livello tra il test e il runner proprietario di Apple.

Un test unitario viene eseguito all'interno del processo dell'app e richiama direttamente il codice. Un test dell'interfaccia utente, invece, avvia l'app come processo separato e interagisce solo tramite l'interfaccia, risultando quindi più lento ma validando l'esperienza effettiva dell'utente.

I simulatori sono più veloci e adatti alla maggior parte dei flussi funzionali in una pipeline. Per la fotocamera, la biometria, le notifiche push, le prestazioni e qualsiasi elemento che interagisca con i sensori hardware sono necessari dispositivi reali, quindi la maggior parte dei team utilizza entrambi i tipi di simulatori in momenti diversi del ciclo.

Ogni test riavvia l'app e attende le animazioni. La stabilità migliora quando si impostano identificatori di accessibilità invece di corrispondere alle etichette, attendere l'esistenza dell'elemento invece di sospenderloping, ripristinare lo stato tra i test e mantenere ogni caso focalizzato su un unico percorso.

Non direttamente, perché i linguaggi e i modelli degli elementi differiscono. Il percorso usuale è quello di conservare i vecchi script come documentazione della copertura prevista, quindi riscrivere ogni scenario come caso XCUITest, partendo dai percorsi che falliscono più spesso in produzione.

Riassumi questo post con: