Entendendo async em testes do Flutter
Veja as ressalvas e boas práticas ao trabalhar com comportamento assíncrono nos seus testes de widget do Flutter.
A classe FakeAsync (do pacote quiver) foi criada para tornar testável código dependente de tempo. Os testes unitários do Flutter rodam em uma Zone FakeAsync. O que isso significa? Da documentação de FakeAsync:
O código de teste pode ser passado como callback para run, que o executa em uma Zone que simula a criação de timers e microtasks, de modo que eles são executados durante chamadas a elapse, que simulam a passagem assíncrona do tempo.
Isso significa que, quando você usa qualquer recurso da linguagem que exige a criação de timers ou microtasks, como Futures e Streams, eles são tratados pelo FakeAsync de um jeito que imita a semântica da assincronia real de forma lógica, mas desconectada do tempo do relógio real.
Observe o código de exemplo abaixo:
import 'package:flutter_test/flutter_test.dart';
void main() {
Future<int> outerF;
final Duration delay = Duration(seconds: 20);
group('Async Tests - Fake Async', () {
setUpAll(() async {
outerF = Future<int>.delayed(delay, () => 42);
final Stopwatch waiting = Stopwatch()..start();
final Future<void> innerF = Future<int>.delayed(Duration(seconds: 3), () {});
await innerF;
waiting.stop();
print('Waited for ${waiting.elapsed}');
});
// Each testWidgets callback is run in a distinct FakeAsync zone
testWidgets('Delayed in test, no time added', (WidgetTester tester) async {
// This will fail due to blowing past the 2 second test case timeout.
final Future<int> f = Future<int>.delayed(delay, () => 1);
await f;
});
testWidgets('Delayed in test, time added', (WidgetTester tester) async {
final Future<int> f = Future<int>.delayed(delay, () => 1);
// So we extend the "time" allowed in the zone, and now it passes.
// Note that this still runs almost immediately.
tester.pump(delay);
await f;
});
testWidgets('Delayed from setUp, no time added', (WidgetTester tester) async {
// This will fail, and will appear to be from a timeout.
await outerF;
});
testWidgets('Delayed from setUp, time added', (WidgetTester tester) async {
// Even with the "time" added though, it will fail. It will not resolve the
// future from a different, Real Async, Zone. The error will still look like
// an exception related to a timeout.
// It will also run very slow, at least as long as the amount of "time" the
// tester binding thinks it will take.
tester.binding.addTime(delay);
await outerF;
});
});
}
O que está acontecendo aqui?
A principal conclusão é que uma Zone FakeAsync é criada para cada caso de teste. Essas Zones são completamente independentes umas das outras no sentido de controlar o tempo (é claro que variáveis e referências continuam obedecendo às regras de escopo do Dart). Elas não conseguem acessar trabalho assíncrono de outras Zones, reais ou falsas.
O mesmo vale para o seu código de Widget ao usar tester.pumpWidget(). Qualquer comportamento assíncrono no seu Widget não será aguardado. Isso causa uma série de problemas ao testar árvores de widgets que contêm imagens.
Imagens são problemáticas por dois motivos:
O asset manifest não é criado para testes.
Assim, não há como o AssetBundle carregar os bytes da sua imagem (Asset). Felizmente, existe uma solução: criar seu próprio subtipo de AssetBundle que carrega os bytes de todas as imagens antes de rodar os testes. O padrão para isso está logo abaixo. Isso resolve a primeira exceção que você receberia no exemplo anterior.
class TestAssetBundle extends CachingAssetBundle {
TestAssetBundle(Map<String, List<String>> assets) : _assets = assets {
for (String assetList in assets.keys) {
for (String asset in assets[assetList]) {
_assetMap[asset] = bytesForFile(asset);
}
}
}
final Map<String, ByteData> _assetMap = <String, ByteData>{};
final Map<String, List<String>> _assets;
@override
Future<ByteData> load(String key) {
if (key == 'AssetManifest.json') {
return Future<ByteData>.value(bytesForJsonLike(_assets));
}
return Future<ByteData>.value(_assetMap[key]);
}
}
ByteData bytesForJsonLike(Map<String, dynamic> jsonLike) => ByteData.view(
Uint8List.fromList(const Utf8Encoder().convert(json.encode(jsonLike)))
.buffer);
ByteData bytesForFile(String path) => ByteData.view(
Uint8List.fromList(File('../' + path).readAsBytesSync()).buffer);
Essa classe é geralmente aplicável. Você monta o bundle assim:
final AssetBundle bundle = TestAssetBundle(<String, List<String>>{
'assets/dart-logo.png': <String>['assets/dart-logo.png'],
});
Você pode incluir, na lista de cada entrada, vários assets para diferentes densidades de pixel. O tester do Flutter tem uma densidade de pixel fixa, então normalmente você só precisa fornecer um item ali.
Chamadas à Flutter Engine
A operação que decodifica os bytes em uma imagem desenhável vem da Flutter Engine, por meio de uma chamada a uma função nativa. Essa é uma operação assíncrona e, mais uma vez, o tester não vai esperar que ela termine. Não há nada que você possa fazer em uma Zone FakeAsync para contornar isso.
Isso leva a algumas leis de ferro para testar árvores de widgets que contêm imagens:
-
Use DefaultAssetBundle para carregar os bytes das imagens que serão usadas pelos testes desse arquivo.
-
Em uma Zone FakeAsync, ou seja, em testes de widget normais, não dependa do tamanho implícito nem da presença de imagens em nenhum tipo de asserção. Se essa asserção for necessária, envolva sua imagem em um SizedBox ou em outro mecanismo para ter controle determinístico sobre o tamanho do widget.
-
Se você não souber o tamanho da imagem em tempo de desenvolvimento (talvez ela venha de conteúdo do usuário e possa variar), talvez precise testar com testes de integração ou ponta a ponta. Vale pensar no que você quer entender sobre o widget que está sendo testado.
-
Se você está procurando testes de regressão visual, há opções disponíveis que vamos discutir na seção abaixo.
É possível ter semântica async real em testes unitários?
A resposta curta é sim, mas a técnica descrita aqui deve ser usada apenas em contextos bem específicos. Abaixo, vamos discutir um conjunto de boas práticas em torno dessa técnica.
A solução é bem simples, como mostra o exemplo a seguir:
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
void main() async {
LiveTestWidgetsFlutterBinding();
Future outsideFuture;
setUp(() {
outsideFuture = Future.microtask(() {
return 'outside';
});
});
testWidgets("awaiting future with value from setUp works", (t) async {
Future insideFuture = Future.microtask(() {
return 'inside';
});
}
Esse código vincula o TestWidgetsFlutterBinding a um LiveTestWidgetsFlutterBinding, que executa o código de teste em uma zona assíncrona real. Isso significa que, se você aguardar um evento assíncrono que leva 10 minutos, seu teste vai rodar por pelo menos 10 minutos. Se o evento que você está aguardando tiver desempenho não determinístico, seus testes também terão.
Infelizmente, embora isso esteja disponível, oferece pouco benefício ao usar o flutter test. O motivo pelo qual a maioria dos desenvolvedores vai querer usar o LiveTestWidgetsFlutterBinding é quando estão tentando entender o comportamento dos seus testes. Felizmente, existe um jeito mais fácil de acessar esse modo de binding, que também é muito mais útil. Você pode rodar seu teste em um dispositivo usando flutter run path/to/your_test.dart.
Uma ressalva ao executar seu caso de teste com flutter run é que as asserções de matchesGolden vão lançar uma exceção. Uma boa prática é colocar os testes de Goldens em um diretório separado, sabendo que esses testes só devem ser chamados com flutter test.
O que isso significa para imagens nos meus testes?
Esse modo não muda o fato de que testes de Widget não são o lugar para fazer asserções de layout, exceto nos casos mais básicos. Se o seu layout depende de imagens ou outros assets cujo tamanho é desconhecido em tempo de desenvolvimento, suas asserções não vão funcionar como esperado.
Se você souber o tamanho dos assets em tempo de desenvolvimento e quiser fazer asserções de layout (como isOnstage), recomendamos envolver o widget em um ConstrainedBox, ou em um SizedBox, para garantir que o Widget ocupe o espaço que você espera no layout.
Principais conclusões
Testar seus widgets é fundamental para a manutenibilidade da sua aplicação. Testes unitários são a forma mais rápida e produtiva de testar seu código, e o testWidgets oferece recursos incríveis para testar unitariamente a parte mais visível da sua aplicação. Dito isso, este artigo mostra que há algumas ressalvas a considerar e algumas boas práticas a seguir.
Ressalvas
-
testWidgets serve para testar o comportamento do Widget, não a aparência ou o layout dele.
-
FakeAsync tem semântica para deixar seus testes rápidos, mas exige que você mude a forma como pensa sobre seu app.
-
O código assíncrono executado em tester.runAsync, e dentro de um caso de teste, roda em tempo real.
-
O código assíncrono de fora do caso de teste, e dentro da árvore de widgets, roda em tempo simulado.
Você não pode cruzar entre essas Zones.
Seu código de teste não deve depender de assincronia na árvore de widgets.
-
Use tester.pump e tester.pumpAndSettle para disparar frames e garantir que as animações tenham terminado.
Boas práticas
Use testes de driver para testes de integração
-
Coloque-os em um diretório driver_test/. Eles são demorados e caros, e isso permite rodá-los apenas quando necessário.
Use testes de goldens para evitar regressões nos seus layouts e na aparência dos widgets.
-
Coloque-os em um diretório separado dentro de test/ (ou fora dele). Rode-os apenas quando for necessário. Use --update-goldens para capturar as mudanças pretendidas.
-
Não dependa de chamadas HTTP, carregamento de arquivos, imagens e outras fontes de assincronia em testes de Widget.
-
Se você não puder evitar o carregamento de AssetImage, use um TestAssetBundle. Conte pra gente nos comentários se você quiser ver isso em um pacote no pub.
Com essas ferramentas em mãos, você deve estar pronto para adicionar mais cobertura de testes à sua aplicação Flutter. Boas codificações!