Por que você deveria fazer smoke test do seu código de exemplo, e como fazer isso no Flutter
Saiba por que apps de exemplo precisam de smoke tests e como usar testes de widget do Flutter com o Travis CI para detectar quebras a cada mudança e entre versões do Flutter.
[ Se você já está convencido de que quer fazer smoke test nos seus exemplos Flutter, pode pular para “Smoke test no Flutter” abaixo. O que segue é um guia geral aplicável a qualquer tecnologia. ]

Quando estão aprendendo uma tecnologia nova, mais cedo ou mais tarde os desenvolvedores querem ver códigos de exemplo. Não só algumas linhas, também. Muitas vezes, querem ver um projeto inteiro e como ele é montado.
Isso, por si só, significa que qualquer biblioteca, framework ou SDK precisa manter uma série de apps de exemplo. Mas tem mais.
Os exemplos são mais úteis quando são focados. Um erro clássico é enfiar tudo o que há para saber em um único app de exemplo. Isso é mais fácil para quem escreve (só um app para criar e manter), mas não ajuda quem está chegando. Ninguém aprende tudo de uma vez.
Com qualquer tecnologia suficientemente complexa, o desenvolvedor primeiro quer ver algum código de exemplo do básico (“hello world”), depois talvez um app pequeno (TodoMVC, app do HN) e, então, exemplos focados conforme a necessidade (rede, paralelismo, animação etc.). A ideia é que ele nunca precise tentar entender vários conceitos difíceis ao mesmo tempo.
(Sim, exemplos muito complexos, do mundo real, são valiosos. Mas, de modo geral, não para iniciantes ou desenvolvedores intermediários. Eles são ótimos quando você já conhece boa parte da tecnologia, assim consegue navegar pelo exemplo complexo e identificar as partes relevantes para você naquele momento.)
Para quem escreve os exemplos, isso significa muitos apps pequenos e independentes. O que, por sua vez, significa muitos repositórios de código. E qualquer um deles pode (e vai) ficar desatualizado, mais cedo ou mais tarde.

Você não quer que o código de exemplo fique desatualizado. Para um desenvolvedor, poucas coisas são mais frustrantes do que se empolgar com uma tecnologia nova, tentar rodar um app de exemplo e vê-lo falhar.
Então, resumindo:
-
Uma boa cobertura de exemplos exige muitos apps de exemplo independentes. Para efeito de argumentação, digamos que temos 100 apps de exemplo independentes.
-
Cada app de exemplo precisa ser mantido. Se houver qualquer quebra grande no caminho, precisamos saber disso o quanto antes.
O que fazer? Aqui estão algumas opções:
Não fazer nada
Erros nos exemplos acabam sendo percebidos pela comunidade mais cedo ou mais tarde, mas, quando você fica sabendo, eles já causaram estrago. Isso não só gera frustração nas pessoas que encontram a quebra, como provavelmente será amplamente divulgado mais cedo ou mais tarde, prejudicando a reputação do seu projeto.
Você ficará chocado (chocado!) ao saber que esta é, de longe, a opção mais usada para repositórios de exemplo.
Testar manualmente
Alguma pobre alma é encarregada de verificar manualmente os 100 exemplos toda vez que sai uma nova versão da tecnologia subjacente.
Muitas equipes fazem isso, e você provavelmente consegue imaginar como isso acaba, ou pelo menos como isso mantém a pressão para ter bem menos do que 100 exemplos.
Executar análise estática na Integração Contínua (CI)
Para linguagens fortemente tipadas, isso já é bem melhor do que a opção anterior. Mas a análise estática não pega todas as quebras. Um app sem erros estáticos ainda pode falhar ao compilar ou travar em tempo de execução.

Testes unitários completos na CI
Testes unitários são indispensáveis, mas não são uma boa ferramenta para essa tarefa específica. A maioria dos códigos de exemplo tem lógica trivial (por exemplo, “esta função sempre retorna 42”), que não vale a pena testar. Além disso, poucas tecnologias mudam de um jeito que quebra seus testes unitários individuais, então não é isso que você quer testar. Você quer testar se o app de exemplo, montado por completo, funciona.
Mas, claro, se você tiver recursos para testar tudo com testes unitários, ótimo.
Testes funcionais / de integração completos na CI
Esta é a melhor opção se você tiver tempo e recursos. O que, convenhamos, você não tem. Não para 100 repositórios de exemplo diferentes.
Se você conseguir, então é obviamente fantástico. Você verifica que o app não só passa na análise estática e compila, como também roda em um ambiente parecido com o do mundo real. (Já que estamos sonhando: vamos testar os apps de exemplo em todos os sistemas operacionais suportados, tanto em dispositivos reais quanto em emuladores.)
Colocar os exemplos diretamente no repositório da tecnologia
Quando você desenvolve (e testa) seus exemplos no mesmo repositório da tecnologia que eles “exemplificam” (como o Flutter faz com a Flutter Gallery), não há chance de ficarem desatualizados. Quando a tecnologia subjacente muda de um jeito que quebra o exemplo, o build fica vermelho e a equipe de desenvolvimento fica muito motivada a corrigir o código de exemplo.
O problema é que você não consegue fazer isso com muitos exemplos. Isso deixaria o desenvolvimento mais lento. Além disso, na maioria das vezes, seus exemplos dependem de tecnologias que você não controla, então não dá para simplesmente colocar o exemplo no mesmo repositório.
Smoke test
O termo “smoke test” vem da engenharia de hardware. É a primeira linha de Garantia de Qualidade: “quando você liga o aparelho, sai fumaça dele?” Se sair, não há necessidade de testes mais aprofundados.
O termo ganhou um significado mais amplo. Smoke tests são, basicamente, testes funcionais ou de integração muito rápidos e incompletos. Alguns os chamam de sanity checks (verificações de sanidade).
Smoke tests pegam seu código, fazem o build, executam e verificam uma coisa ou duas. Eles não vão verificar que seu software está 100% funcional e correto. Em um app de produção, eles funcionam como uma saída rápida: se o smoke test falhar, o build inteiro falha. E isso acontece rapidamente.
O que quero dizer é que, para um app de exemplo, o smoke test costuma ser tudo o que você precisa.
Recomendação:
Todo app de exemplo, por menor que seja, vem com um smoke test.
-
O smoke test pode ser bem curto, mas deve abrir todas as telas e testar pelo menos uma funcionalidade principal.
-
O smoke test é executado pela sua ferramenta de CI em todo commit do repositório de exemplos (incluindo pull requests).
-
O smoke test também é executado periodicamente (por exemplo, uma vez por semana) para verificar se ele ainda está em sincronia com a tecnologia subjacente (que pode ter sido atualizada).
-
A CI executa o smoke test tanto contra a versão estável atual da tecnologia subjacente quanto contra a versão de desenvolvimento. (Esta última vai dar um alerta antecipado de quebras que estão por vir.)
Você (ou a equipe responsável pelo exemplo) assina as notificações da CI.
Você exibe o badge da CI (build vermelho ou verde) no README do exemplo.
[ Isto marca o fim da parte geral deste post. Continue apenas se você se importa com como implementar isso nos seus exemplos Flutter, no Travis. ]

Fazendo smoke test em apps de exemplo do Flutter no Travis CI
A boa notícia é que o Flutter oferece um framework de testes muito bom: flutter.io/testing. Ele tem recursos e funcionalidades de conveniência para testes unitários, testes de widget e testes de integração.
Com tempo e recursos ilimitados, você gostaria de usar testes de integração completos. Isso significa rodar seus apps de exemplo em um dispositivo, ou pelo menos no iOS Simulator / Android Emulator. Graças ao
FlutterDriver, isso é mais fácil do que você imagina, mas ainda assim exige instalar um emulador, executá-lo, conectar-se a ele e assim por diante, para cada commit. Para a maioria dos exemplos de Flutter por aí, isso é exagero.
Em vez disso, você quer usar um teste de widget. Lembre-se: no Flutter, tudo é um widget, e isso vale para o app inteiro também. Você pode fazer teste de widget no app inteiro com facilidade. Assim:
testWidgets('smoke test', (WidgetTester tester) async {
final app = MyApp();
await tester.pumpWidget(app);
expect(find.text("0"), findsOneWidget);
await tester.tap(find.byIcon(Icons.add));
await tester.pump();
expect(find.text("1"), findsOneWidget);
});
Este teste roda totalmente sem interface (headless) e, no meu notebook de trabalho, leva 50 milissegundos. Ainda assim, ele simula o framework Flutter inteiro.
Só por diversão, tente rodá-lo como um app completo (flutter run test/smoke_test.dart em vez do habitual
flutter test), e você verá algo assim:
flutter run
(em vez de
flutter test
). Você deve conseguir ver “Redux”, “ValueNotifier”, “ScopedModel” etc. na barra de título lá em cima. Estou mostrando isto em vez do teste acima porque aquele termina rápido demais, então não há muito o que ver.
Isso é útil para visualizar seu teste e verificar se ele está fazendo o que você acha que está fazendo.
.travis.yml
Agora que você tem um smoke test, vamos configurar o Travis CI para observar seu repositório (as instruções de primeiros passos estão aqui) e adicionar o seguinte
.travis.yml
arquivo na raiz do seu repositório. Vou explicar o conteúdo passo a passo abaixo. Mas, antes, vamos ver o arquivo inteiro:
os:
- linux
sudo: false
addons:
apt:
sources:
- ubuntu-toolchain-r-test
packages:
- libstdc++6
- fonts-droid
git:
depth: 3
cache:
directories:
- $HOME/.pub-cache
env:
- FLUTTER_VERSION=beta
- FLUTTER_VERSION=dev
matrix:
allow_failures:
- env: FLUTTER_VERSION=dev
before_script:
- git clone [https://github.com/flutter/flutter.git](https://github.com/flutter/flutter.git) -b $FLUTTER_VERSION
- ./flutter/bin/flutter doctor
script:
- ./flutter/bin/flutter test
As linhas no topo — tudo entre os e fonts-droid — são necessárias para qualquer teste de Flutter.
O Yegor tem um texto explicando isso
se você quiser saber mais.
Costumo adicionar a opção git: depth — ela diz ao Travis para buscar as últimas versões do git do seu app, em vez de todo o histórico do repositório.
Outra configuração opcional, mas útil, é cache. Ela pode deixar seus builds mais rápidos, além de economizar recursos para as pessoas maravilhosas do Travis.
Depois, temos isto:
env:
- FLUTTER_VERSION=beta
- FLUTTER_VERSION=dev
Isso diz ao Travis para executar dois builds separados: um com a variável personalizada FLUTTER_VERSION
definida como beta (builds estáveis do Flutter) e outro com ela definida como dev (builds ~nightly do Flutter). Esses dois builds rodam em paralelo. Vamos usar a variável abaixo.
Em seguida, permitimos que o build FLUTTER_VERSION=dev falhe usando a funcionalidade de matriz de builds do Travis:
matrix:
allow_failures:
- env: FLUTTER_VERSION=dev
É bom saber se nosso exemplo funciona com a versão mais recente do Flutter, mas não queremos deixar nosso exemplo vermelho sempre que falhar ali. Considere o build FLUTTER_VERSION=dev como um sistema de alerta antecipado para mudanças que quebram. Ele pode nos avisar sobre coisas que estão chegando ao Flutter e que deveríamos corrigir, ou nos preparar para corrigir, no nosso exemplo. Mas pode haver falsos positivos aqui, afinal, é um canal experimental.
Em seguida, usamos de fato a variável $FLUTTER_VERSION ao instalar o Flutter:
before_script:
- git clone [https://github.com/flutter/flutter.git](https://github.com/flutter/flutter.git) -b $FLUTTER_VERSION
O Git busca o branch especificado com -b, que, no nosso caso, é beta ou
dev.
Ainda em before_script, executamos flutter doctor. Isso serve para garantir que a instalação do Flutter está íntegra.
- ./flutter/bin/flutter doctor
Observe que não adicionamos a ferramenta flutter ao $PATH, então a acessamos pelo caminho completo. Isso é só uma questão de preferência pessoal.
Por fim, executamos o teste:
script:
- ./flutter/bin/flutter test
Legal! Você pode fazer commit do arquivo .travis.yml no seu repositório, dar push no GitHub, ir até o
travis-ci.org e pronto:
O build leva cerca de 2 minutos, a maior parte com instalação (o teste em si leva no máximo alguns segundos).
Executar o teste periodicamente
Agora, não queremos que o build rode apenas a cada commit ou PR (o padrão com Travis + GitHub), mas também periodicamente. Afinal, na maioria das vezes, quando os exemplos quebram, não é porque alguém os alterou, e sim porque a tecnologia subjacente mudou por baixo deles.
Podemos usar o recurso “Cron Job” do Travis. Basta ir até o travis-ci.org e configurá-lo.

Configurar notificações
Por padrão, o Travis enviará um e-mail sempre que o build falhar. Mas eu recomendo muito verificar as configurações dessas notificações. Você pode não só garantir que a pessoa ou equipe certa seja notificada, como também configurar coisas mais sofisticadas, como alertas no IRC ou no Slack.
Adicionar badge
Por último, mas não menos importante, adicione o badge de build ao README.md do seu exemplo. Vá até o Travis de novo e clique no ícone do badge. Ele vai gerar o código para você usar.

Cole isto no topo do seu README.md. Depois, faça commit, push e pronto:

Parabéns. Seu código de exemplo agora tem smoke test.