Novidades sobre testes no Flutter
Testes de integração atualizados com suporte ao Firebase Test Lab no mobile; suporte independente para web e desktop também!
O objetivo do Flutter é oferecer um framework aberto para criar rapidamente apps nativos bonitos em múltiplas plataformas. Uma grande parte disso é a sua capacidade de testar facilmente seus apps Flutter, para garantir que funcionem e tenham a aparência que você deseja nas plataformas para as quais está desenvolvendo. Parte desses testes pode ser feita com testes unitários escritos usando o framework de testes unitários embutido no Dart. Os testes unitários em Dart funcionam muito bem para testes que não são de UI; eles rodam na sua máquina de desenvolvimento e não dependem da interface gráfica do seu app Flutter.
Os testes de integração (também chamados de testes end-to-end ou testes de GUI) são um passo além dos testes unitários, porque tentam simular um usuário interagindo com o app, por exemplo, apertando botões, selecionando itens e digitando no teclado. Esses testes são automatizados para evitar que pessoas façam esse tipo de trabalho repetitivo, já que, sinceramente, não somos tão bons nisso. Nossa solução inicial para evitar a interação humana foi uma forma especial de escrever testes no Flutter. Esses testes são executados no host, como os testes unitários em Dart, e controlam o app rodando em um dispositivo real ou virtual, exatamente como uma pessoa faria. Esses tipos de teste eram chamados de testes com Flutter driver, porque você usa o
flutter_driver package e a linha de comando flutter drive para controlar a interface gráfica do seu app.
Infelizmente, os testes com Flutter driver têm vários problemas. Um deles é que os testes rodam na máquina de desenvolvimento e se comunicam com o app no dispositivo, o que significa que os testes não são adequados para rodar em um device farm como o Firebase Test Lab. Outro problema é que ter um processo separado para os testes dificulta verificar o estado do app. Você pode checar a saída, mas como saber, por exemplo, o estado interno do app? E, por fim, a API do flutter_driver é mais complicada do que precisa ser, principalmente quando se trata de escrever o código para encontrar os widgets adequados na tela para testar.
E, para resolver esses problemas e continuar melhorando a experiência de testes no Flutter em um número crescente de alvos, temos o prazer de anunciar a versão 1.0 de o plugin integration_test, uma forma mais simples de testar seus apps Flutter que também oferece suporte ao Firebase Test Lab.
Primeiros passos com o integration_test
Usar o plugin integration_test exige duas etapas. Primeiro, adicione o plugin como dependência de desenvolvimento no arquivo pubspec.yaml
e use flutter pub get para trazer o plugin para o seu projeto:
# …
dev_dependencies:
flutter_test:
sdk: flutter
integration_test: ^1.0.0
# …
Depois, use o pacote integration_test no código de teste:
// widget_integration_test.dart
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:hello_world/main.dart';
import 'package:integration_test/integration_test.dart';
void main() {
IntegrationTestWidgetsFlutterBinding.ensureInitialized();
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 incremented.
expect(find.text('0'), findsNothing);
expect(find.text('1'), findsOneWidget);
});
}
Observe a importação do pacote integration_test e a chamada a IntegrationTestWidgetsFlutterBinding.ensureInitialized(), que garante que o pacote seja inicializado corretamente. Observe também o código de teste padrão de WidgetTester. Este é o mesmo código de teste gerado pelo template padrão do app Counter durante o flutter create.
Embora o integration_test permita que seus testes sejam empacotados no app de forma autônoma (o que é um requisito para device farms como o Firebase Test Lab), ele exige uma certa "mágica de build", que vamos abordar a seguir. Durante o processo de desenvolvimento dos testes, no entanto, é útil poder executá-los de forma interativa pela linha de comando e, para isso, você precisará de um novo ponto de entrada:
// integration_test.dart
import 'package:integration_test/integration_test_driver.dart';
Future<void> main() => integrationDriver();
Esta chamada a integrationDriver é um wrapper de conveniência em torno do plugin integrationDriver
para executar seus novos testes com o comando flutter drive:
$ flutter drive \
--driver=test_driver/integration_test.dart \
--target=test/widget_integration_test.dart
Esse comando instala seu app no simulador, executa seus testes e mostra os resultados.
Este teste específico está rodando no iOS, mas o plugin integration_test também funciona para Android, bastando alterar a opção
--device-id, conforme necessário. Além disso, você pode executar seus testes de integração contra os alvos web e desktop também, embora essa funcionalidade ainda esteja em pré-lançamento.
Executando no Firebase Test Lab
Depois de confirmar que seus testes funcionam localmente, usando hardware virtual ou físico, você pode colocar seu app para rodar na enorme variedade de dispositivos disponíveis no Firebase Test Lab.
O Firebase Test Lab é uma infraestrutura de testes de apps baseada na nuvem. Com uma única operação, você pode testar seu app Android ou iOS em uma grande variedade de dispositivos e configurações, e ver os resultados (incluindo logs, vídeos e capturas de tela) no console do Firebase. Um dos grandes avanços do plugin
integration_test é a capacidade de executar seus apps Flutter direcionados para Android e iOS no Firebase Test Lab, permitindo testar em centenas de dispositivos simultaneamente para encontrar problemas específicos de plataforma, de formato de tela ou de dispositivo antes de lançar seu app.
Para executar um teste no Firebase Test Lab, você precisa fazer algumas configurações e usar comandos do Gradle para criar um teste de instrumentação para Android e iOS, conforme o caso. Para esses detalhes, confira a nova documentação sobre testes de integração em flutter.dev.
Migrando dos testes com Flutter driver
Para quem já tem testes com flutter_driver, migrar para a nova API não é tão difícil. Além da inicialização apropriada mencionada antes, você também precisa migrar para a nova API WidgetTester.
A API flutter_driver (mostrada à esquerda) e a API WidgetTester (mostrada à direita) são conceitualmente muito semelhantes, mas você pode ver que muitos detalhes são diferentes. Por exemplo, em vez de chamar o método
waitFor no flutter_driver, você chama o método pumpAndSettle
no WidgetTester. O primeiro aguarda um widget específico aparecer, enquanto o segundo aguarda a fase de renderização da interface do app se estabilizar. Depois de ter um widget específico, você age sobre ele de forma semelhante nas duas APIs, mas usa objetos diferentes. A API WidgetTest é mais alinhada com o que você está acostumado a ver em testes unitários em Dart. Como você pode ver, o método expect é usado para garantir que o conteúdo de um widget seja o que você espera.
Para os detalhes sobre como mover seus testes de flutter_driver para integration_test e WidgetTester, veja a documentação de migração em flutter.dev.
Testes de UI nativa
Se você tem um app Android ou iOS existente, ao qual está adicionando Flutter usando Add-to-App, provavelmente já tem testes de integração para esses apps nativos que quer aproveitar. Nesse caso, adicione os testes das suas telas Flutter aos testes existentes. No Android, você pode adicioná-los se estiverem escritos com o framework Espresso, usando o plugin espresso, que fornece bindings para testes Espresso de apps Android em Flutter. Em breve teremos um plugin semelhante para oferecer suporte a testes nativos de iOS criados com Earl Grey.
Resumo
Este anúncio apresenta uma nova base para testes de integração usando o novo plugin integration_test
para Flutter. Não só a API é mais simples e consistente, como os testes escritos usando integration_test
podem rodar em centenas de dispositivos diferentes com o Firebase Test Lab. A equipe do Flutter planeja construir sobre essa nova base, atualizando o template flutter create para usar integration_test por padrão, adicionando atualizações à saída dos testes para dar suporte a ferramentas de teste existentes que usam o formato JUnit, adicionando a possibilidade de tirar capturas de tela durante os testes para comparações de golden testing e muito mais. Para a lista completa de detalhes sobre nossas novas recomendações de teste de integração para seus apps e plugins Flutter, veja
a documentação de testes em flutter.dev.
