Flutter - Teste

O teste é uma fase muito importante no ciclo de vida de desenvolvimento de um aplicativo. Isso garante que a aplicação seja de alta qualidade. O teste requer planejamento e execução cuidadosos. É também a fase mais demorada do desenvolvimento.

A linguagem Dart e a estrutura Flutter fornecem amplo suporte para o teste automatizado de um aplicativo.

Tipos de teste

Geralmente, três tipos de processos de teste estão disponíveis para testar completamente um aplicativo. Eles são os seguintes -

Teste de Unidade

O teste de unidade é o método mais fácil de testar um aplicativo. Baseia-se em garantir a correção de um trecho de código (uma função, em geral) ou um método de uma classe. Porém, não reflete o ambiente real e, consequentemente, é a menor opção para encontrar os bugs.

Teste de widget

O teste de widget é baseado em garantir a exatidão da criação, renderização e interação do widget com outros widgets conforme o esperado. Ele vai um passo além e fornece um ambiente quase em tempo real para encontrar mais bugs.

Teste de integração

O teste de integração envolve o teste de unidade e o teste de widget, juntamente com o componente externo do aplicativo, como banco de dados, serviço da web, etc. Ele simula ou zomba do ambiente real para encontrar quase todos os bugs, mas é o processo mais complicado.

O Flutter oferece suporte para todos os tipos de teste. Ele fornece suporte extensivo e exclusivo para teste de widget. Neste capítulo, discutiremos o teste de widget em detalhes.

Teste de widget

A estrutura de teste de flutter fornece o método testWidgets para testar widgets. Aceita dois argumentos -

Descrição de teste
Código de teste

testWidgets('test description: find a widget', '<test code>');

Etapas Envolvidas

O teste de widget envolve três etapas distintas -

Renderize o widget no ambiente de teste.
WidgetTester é a classe fornecida pela estrutura de teste Flutter para construir e renderizar o widget. O método pumpWidget da classe WidgetTester aceita qualquer widget e o renderiza no ambiente de teste.

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

Encontrando o widget, que precisamos testar.

A estrutura Flutter fornece muitas opções para localizar os widgets renderizados no ambiente de teste e geralmente são chamados de Finders. Os localizadores usados com mais frequência são find.text, find.byKey e find.byWidget.

find.text encontra o widget que contém o texto especificado.

find.text('Hello')

find.byKey encontre o widget por sua chave específica.

find.byKey('home')

find.byWidget encontre o widget por sua variável de instância.

find.byWidget(homeWidget)

Garantir que o widget funcione conforme o esperado.
A estrutura de flutuação fornece muitas opções para combinar o widget com o widget esperado e são normalmente chamados de Matchers . Podemos usar o método expect fornecido pela estrutura de teste para corresponder ao widget, que encontramos na segunda etapa com nosso widget esperado, escolhendo qualquer um dos matchers. Algumas das combinações importantes são as seguintes.

findOneWidget - verifica se um único widget foi encontrado.

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

findNothing - verifica se nenhum widget foi encontrado

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

findWidgets - verifica se mais de um widget foi encontrado.

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

findNWidgets - verifica se um número N de widgets foi encontrado.

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

O código de teste completo é o seguinte -

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

Aqui, renderizamos um widget MaterialApp com o texto Hello usando o widget Text em seu corpo. Em seguida, usamos find.text para encontrar o widget e, em seguida, correspondia-o usando findOneWidget.

Exemplo de Trabalho

Vamos criar um aplicativo simples de flutter e escrever um teste de widget para entender melhor as etapas envolvidas e o conceito.

Crie um novo aplicativo de flutter, flutter_test_app no Android Studio.
Abra widget_test.dart na pasta de teste. Ele tem um código de teste de amostra conforme fornecido abaixo -

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); 
});

Aqui, o código de teste faz as seguintes funcionalidades -

Renderiza o widget MyApp usando tester.pumpWidget.
Garante que o contador seja inicialmente zero usando as combinações de findOneWidget e findNothing.
Encontra o botão de incremento do contador usando o método find.byIcon.
Toque no botão de incremento do contador usando o método tester.tap.
Garante que o contador seja aumentado usando as combinações de findOneWidget e findNothing.

Vamos tocar novamente no botão de incremento do contador e, em seguida, verificar se o contador aumentou para dois.

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

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

Clique no menu Executar.
Clique em testes na opção widget_test.dart. Isso executará o teste e relatará o resultado na janela de resultados.