Flutter - Test

Il test è una fase molto importante nel ciclo di vita di sviluppo di un'applicazione. Assicura che l'applicazione sia di alta qualità. Il test richiede un'attenta pianificazione ed esecuzione. È anche la fase di sviluppo che richiede più tempo.

Il linguaggio Dart e il framework Flutter forniscono un ampio supporto per il test automatizzato di un'applicazione.

Tipi di test

In genere, sono disponibili tre tipi di processi di test per testare completamente un'applicazione. Sono i seguenti:

Test unitario

Lo unit test è il metodo più semplice per testare un'applicazione. Si basa sull'assicurare la correttezza di un pezzo di codice (una funzione, in generale) o un metodo di una classe. Ma non riflette l'ambiente reale e, di conseguenza, è l'ultima opzione per trovare i bug.

Test dei widget

Il test dei widget si basa sull'assicurazione della correttezza della creazione, del rendering e dell'interazione del widget con altri widget come previsto. Fa un ulteriore passo avanti e fornisce un ambiente quasi in tempo reale per trovare più bug.

Test d'integrazione

Il test di integrazione coinvolge sia il test di unità che il test di widget insieme a componenti esterni dell'applicazione come database, servizio web, ecc. Simula o prende in giro l'ambiente reale per trovare quasi tutti i bug, ma è il processo più complicato.

Flutter fornisce supporto per tutti i tipi di test. Fornisce un supporto ampio ed esclusivo per il test dei widget. In questo capitolo, discuteremo in dettaglio il test dei widget.

Test dei widget

Il framework di test Flutter fornisce il metodo testWidgets per testare i widget. Accetta due argomenti:

  • Descrizione del testo
  • Codice di prova
testWidgets('test description: find a widget', '<test code>');

Passaggi coinvolti

Il test dei widget prevede tre passaggi distinti:

  • Renderizza il widget nell'ambiente di test.

  • WidgetTester è la classe fornita dal framework di test Flutter per creare e visualizzare il widget. Il metodo pumpWidget della classe WidgetTester accetta qualsiasi widget e lo visualizza nell'ambiente di test.

testWidgets('finds a specific instance', (WidgetTester tester) async { 
   await tester.pumpWidget(MaterialApp( 
      home: Scaffold( 
         body: Text('Hello'), 
      ), 
   )); 
});

  • Trovare il widget, che dobbiamo testare.

    • Il framework Flutter fornisce molte opzioni per trovare i widget renderizzati nell'ambiente di test e sono generalmente chiamati Finder. I finder utilizzati più di frequente sono find.text, find.byKey e find.byWidget.

      • find.text trova il widget che contiene il testo specificato.

find.text('Hello')

      • find.byKey trova il widget in base alla sua chiave specifica.

find.byKey('home')

      • find.byWidget trova il widget in base alla sua variabile di istanza.

find.byWidget(homeWidget)

  • Garantire che il widget funzioni come previsto.

  • Il framework Flutter fornisce molte opzioni per abbinare il widget al widget previsto e sono normalmente chiamati Matcher . Possiamo utilizzare il metodo di attesa fornito dal framework di test per abbinare il widget, che abbiamo trovato nel secondo passaggio con il nostro widget previsto scegliendo uno qualsiasi dei matcher. Alcuni degli importanti matcher sono i seguenti.

    • findOneWidget: verifica che sia stato trovato un singolo widget.

expect(find.text('Hello'), findsOneWidget);

    • findNothing: verifica che non siano stati trovati widget

expect(find.text('Hello World'), findsNothing);

    • findWidgets: verifica che sia stato trovato più di un singolo widget.

expect(find.text('Save'), findsWidgets);

    • findNWidgets - verifica che siano stati trovati N numero di widget.

expect(find.text('Save'), findsNWidgets(2));

Il codice di prova completo è il seguente:

testWidgets('finds hello widget', (WidgetTester tester) async { 
   await tester.pumpWidget(MaterialApp( 
      home: Scaffold( 
         body: Text('Hello'), 
      ), 
   )); 
   expect(find.text('Hello'), findsOneWidget); 
});

Qui, abbiamo reso un widget MaterialApp con testo Hello utilizzando il widget Text nel suo corpo. Quindi, abbiamo utilizzato find.text per trovare il widget e quindi l'abbiamo trovato utilizzando findOneWidget.

Esempio di lavoro

Creiamo una semplice applicazione flutter e scriviamo un widget di test per comprendere meglio i passaggi coinvolti e il concetto.

  • Crea una nuova applicazione flutter, flutter_test_app in Android Studio.

  • Apri widget_test.dart nella cartella del test. Ha un codice di test di esempio come indicato di seguito:

testWidgets('Counter increments smoke test', (WidgetTester tester) async {
   // Build our app and trigger a frame. 
   await tester.pumpWidget(MyApp()); 
   
   // Verify that our counter starts at 0. 
   expect(find.text('0'), findsOneWidget); 
   expect(find.text('1'), findsNothing); 
   
   // Tap the '+' icon and trigger a frame. 
   await tester.tap(find.byIcon(Icons.add)); 
   await tester.pump(); 
   
   // Verify that our counter has incremented. 
   expect(find.text('0'), findsNothing); 
   expect(find.text('1'), findsOneWidget); 
});

  • Qui, il codice di test esegue le seguenti funzionalità:

    • Esegue il rendering del widget MyApp utilizzando tester.pumpWidget.

    • Assicura che il contatore sia inizialmente zero utilizzando findOneWidget e findNothing matchers.

    • Trova il pulsante di incremento del contatore utilizzando il metodo find.byIcon.

    • Tocca il pulsante di incremento del contatore utilizzando il metodo tester.tap.

    • Assicura che il contatore venga aumentato utilizzando findOneWidget e findNothing matchers.

  • Tocciamo di nuovo il pulsante di incremento del contatore e quindi controlliamo se il contatore è aumentato a due.

await tester.tap(find.byIcon(Icons.add)); 
await tester.pump(); 

expect(find.text('2'), findsOneWidget);

  • Fare clic sul menu Esegui.

  • Fare clic su test nell'opzione widget_test.dart. Questo eseguirà il test e riporterà il risultato nella finestra dei risultati.