Event Loop no Widget Tester
O widget tester do Flutter é uma ótima forma de fazer testes unitários de widgets. Dê uma olhada mais de perto em como ele gerencia o event loop.
O widget tester do Flutter é uma ótima forma de fazer testes unitários em widgets. Ele permite iniciar um ambiente headless em que você pode validar propriedades dos seus widgets, simular gestos como toque ou fling e testar a resposta deles com facilidade.
Este artigo analisa mais de perto como os testes de widget gerenciam o event loop e o que isso significa para tarefas assíncronas.
Pump
Durante minha experiência como desenvolvedor de apps Flutter, percebi que a maioria dos desenvolvedores não entende totalmente o que pump() faz, além do fato de que precisam chamá-lo para que os testes passem.
A documentação afirma que:
Pump dispara uma sequência de frames (build/layout/paint/etc) e, em seguida, esvazia as microtasks.
Uma microtask é qualquer coisa agendada para execução no event loop. Chamar pump() repetidamente esvazia as microtasks e permite que novas sejam criadas.
Digamos que seu widget dependa de algum data store que retorna um Future a ser resolvido. Nos testes, normalmente você tem um store falso que retorna os dados imediatamente. Isso não muda o fato de que um Future ainda é uma microtask que precisa ser resolvida. Você precisará chamar pump para esvaziar essas tarefas e disparar o build, para que seu widget possa ser testado.
Sem pump, o fluxo de eventos fica assim:
Com pump, você consegue reconstruir o widget e o teste passa:

Você pode pensar que chamar pump avança o relógio, porque é assim que seu widget funciona na vida real. Você inicia uma busca de dados, algum tempo depois o Future é resolvido e seu widget exibe os dados. Na realidade, pump não avança o relógio. Por exemplo, uma animação com duração predefinida nunca termina só chamando pump.
Para resolver esse problema, você terá que chamar pump com uma duração. Ele esvazia as microtasks, agenda um frame, mas também avança o relógio pela duração especificada. Ele efetivamente agenda um novo frame e então finge que todos os frames foram perdidos até a duração expirar, como se o sistema tivesse estado ocupado demais para agendar o app naquele momento. Isso permite pular animações rapidamente, e é basicamente assim que a API pumpAndSettle é implementada.
FakeAsync
Pump consegue pular adiante dessa forma porque o WidgetTester roda na FakeAsync zone. Essa zone cria um ambiente previsível e controlável para os testes rodarem. O lado negativo é que Futures (e trabalho assíncrono em geral) se comportam de forma bem diferente nessa zone em comparação com seu app real.
Considere este exemplo:
import "dart:async";
import "package:flutter_test/flutter_test.dart";
void main() {
Future future;
setUp(() {
future = new Future.value();
});
testWidgets("awaiting future with value from setUp works", (WidgetTester tester) async {
await future;
});
}
Este teste nunca termina porque ninguém está chamando pump(Duration) para avançar o tempo no future aguardado na linha 12.
A solução é usar uma função chamada runAsync para fazer o trabalho assíncrono rodar fora da fake zone, o que o desvincula do fluxo de tempo controlado pelo teste e permite que ele rode em tempo real.
import "dart:async";
import "package:flutter_test/flutter_test.dart";
void main() {
Future future;
setUp(() {
future = new Future.value();
});
testWidgets("awaiting future with value from setUp works", (WidgetTester tester) async {
await tester.runAsync(() => future);
});
}
Embora este seja um exemplo simples, ele fica mais sutil quando o código do aplicativo (ou até do framework) começa a fazer trabalho assíncrono.
Vamos ver mais dois exemplos.
Snackbar
Imagine que você escreveu um widget que mostra uma snackbar com um botão de cancelar quando uma operação assíncrona está em andamento. O usuário pode tocar no botão de cancelar e interromper a operação. Você quer escrever um teste para o botão de cancelar, e isso deveria ser trivial:
Criar o widget snackbar com algum trabalho assíncrono
Simular o toque no botão
Verificar o estado do widget
Você pode ser tentado a codificar isso definindo um Future.delayed() para o seu trabalho assíncrono. Logo descobre que o teste não funciona como esperado. Você vê que, enquanto a simulação do toque no botão é executada, o handler de toque do seu widget nunca é chamado.
O problema é que Future.delayed() roda dentro da fake async zone e fica esperando alguém avançar o tempo. Os eventos de toque não podem ser consumidos porque os frames não avançam além da operação anterior.
A solução, mais uma vez, é colocar o trabalho em runAsync para que ele possa rodar em tempo real, deixar o botão consumir o toque e disparar o fluxo que o usuário quer testar.
runAsync faz seu trabalho assíncrono rodar em tempo real. Se você colocar um Future.delayed(5 segundos) ali, seu tempo real de teste será prolongado em 5 segundos bem reais.
Method Channel
Às vezes, o FakeAsync atrapalha de formas ainda mais sutis. Se uma chamada do framework aguarda um platform channel, esse await não consegue ser concluído, mesmo que o lado nativo esteja tentando enviar dados, porque os testes rodam em uma fake zone. Infelizmente, não há solução do lado do aplicativo para isso. Os channels controlados pelo framework precisam ser rastreados explicitamente pelo framework de testes e avançados manualmente para que possam terminar. Então, por favor, abra uma issue no Flutter se você encontrar esse cenário, pois adoraríamos saber mais.
Resumindo…
Tenha estes pontos em mente:
-
Se seus testes de widget envolvem operações assíncronas, qualquer trabalho assíncrono real nos testes precisa ser feito em runAsync, incluindo construções falsas de Future.delayed().
-
Qualquer trabalho assíncrono real executado nos seus widgets não pode ser testado via testes de widget. Você precisa injetar um serviço sobrescrevível para poder assumir a execução da tarefa assíncrona no teste ou fornecer uma implementação síncrona.