Testes no Flutter: guia completo para iniciantes

Testes no Flutter: guia completo para iniciantes | Alura Cursos Online

List<Student> lista_estudantes = await getListStudentsFromServer();
int lista_notas = await getListScoreFromServer(examDate: DateTime.parse("2024-03-01"));
for (int i = 0; i < lista_notas.lenght(); i++){
	lista_estudante[i].score = lista_notas[i];
}

"Tradeoff"	Teste de Unidade	Teste de Widget	Teste de Integração
Confiabilidade	Baixa	Média	Alta
Custo de Manutenção	Baixo	Médio	Alto
Dependências	Poucas	Algumas	Muitas
Velocidade de execução	Rápido	Rápido	Lento

Tipo do Teste	Pacotes recomendados	Linha de comando
Unidade	test	flutter pub add dev:test
Widgets	flutter_test	Não é necessário
Dependências Simuladas	mockito e build_runner	flutter pub add dev:mockito dev:build_runner
Integração	integration_test	flutter pub add 'dev:flutter_test:{"sdk":"flutter"}' 'dev:integration_test:{"sdk":"flutter"}'

import "package:flutter_testes_estudo/contador.dart";
import 'package:test/test.dart';
void main() {
  group("Testar inicialização, incremento e decremento:", () {
    test("O atributo 'valor' deve começar em 0.", () {
      Contador contador = Contador();
      expect(contador.valor, 0);
    });
    test("O método 'incrementar' deve aumentar o valor de 'valor' em 1.", () {
      Contador contador = Contador();
      contador.incrementar();
      expect(contador.valor, 1);
    });
    test("O método 'decrementar' deve diminuir o valor de 'valor' em 1.", () {
      Contador contador = Contador();
      contador.decrementar();
      expect(contador.valor, -1);
    });
  });
}

void expect(
	dynamic actual,
	dynamic matcher, {
	String? reason,
	Object? skip,
	@Deprecated('Will be removed in 0.13.0.') bool verbose = false,
	@Deprecated('Will be removed in 0.13.0.') ErrorFormatter? formatter,
})

test("O método 'atribuir valores' deve retornar uma lista não nula.", () {
  Contador contador = Contador();
  contador.valor = 2;
  List<int> resultado = contador.multiplicarValor([-3, -2, -1, 0, 1, 2, 3]);
  expect(resultado, !null); // ERRO AQUI!
});

test("O método 'multiplicarValor' deve retornar uma lista não nula.", () {
      Contador contador = Contador();
      contador.valor = 2;
      List<int> resultado = contador.multiplicarValor([-3, -2, -1, 0, 1, 2, 3]);
      expect(resultado, isNotNull);
});

Matcher	Propósito
equals	O mais básico dos comparadores, compara se um objeto é igual ao outro, não necessariamente apenas número, mas qualquer objeto. Funciona de forma análoga ao ==.
isNegative, isNonNegative, isPositive, isNonPositive, isZero	Muito útil para comparações numéricas, esses matcher fazem verificações do número comparado com o número 0.
lessThan, lessThanOrEqualTo, greatThan, greatThanOrEqualTo	Outros comparadores extremamente úteis, esses fazem verificações análogas aos operadores <, <=, >, >=.
isTrue	Similar a fezer um equals(true).
isFalse	Diferente de fazer um equals(false), o comparador isFalse combinará com qualquer objeto que não seja um bool de valor true.
isEmpty	Verifica se uma coleção está vazia. Esse comparador só é aplicável a objetos que possuam o método isEmpty.
isNotEmpty	Verifica se uma coleção não está vazia. Esse comparador só é aplicável a objetos que possuam o método isNotEmpty.
isNaN	Verifica se o objeto testado é um "Not a Number", ou seja, um elemento que não pode ser convertido para um número.
isList, isMap	Verifica se o objeto testado é uma das coleções mais usadas no Flutter, List ou Map respectivamente.
isNull	Verifica se o objeto testado é nulo.
isNotNull	Verifica se objeto testado é diferente de nulo.
contains(Object? expected)	Verifica se a coleção testada contém o objeto expected esperado.
returnsNormally	Verifica se a função comparada é encerrada sem levantar nenhuma exceção.
isA()	Verifica se o objeto comparado é uma um instância de .

List<int> multiplicarValor(List<int> listaParaMultiplicar) {
    if (listaParaMultiplicar.isEmpty) throw ListaVaziaException();
    for (int numero in listaParaMultiplicar) {
      numero = numero * valor;
    }
    return listaParaMultiplicar;
}

test(
        "O método 'multiplicarValor' deve lançar uma exceção se receber uma lista vazia.",
        () {
    Contador contador = Contador();
    expect(() => contador.multiplicarValor([]),
        throwsA(isA<ListaVaziaException>()));
});

class ContadorDatabase {
  Future<void> abrirBanco() async {
    //... Abre o banco
  }
Future<void> fecharBanco() async {
//... Fecha o banco
}
Future<void> salvar(int valor) async {
//... Salva valor no banco
throw UnimplementedError();
}
Future<int> ler() async {
//... Recupera valor no banco
throw UnimplementedError();
}
Future<int> remover() async {
//... Remove valor do banco
throw UnimplementedError();
}
}

class Contador {
	...
lerDoBanco() async {
	final ContadorDatabase db = ContadorDatabase();
	int dbValor = await db.ler();
	valor = dbValor;
}

salvarNoBanco() async {
	final ContadorDatabase db = ContadorDatabase();		
	db.salvar(valor);
}

}

...
import 'package:flutter_testes_estudo/data/contador_database.dart';
import 'package:mockito/annotations.dart';
@GenerateMocks([ContadorDatabase])
void main() {
	group("Testar inicialização, incremento e decremento:", () {
...

group("Métodos de persistência de dados:", () {
  test("Ler dados no banco.", () async {
    MockContadorDatabase mockContadorDatabase = MockContadorDatabase();
    when(mockContadorDatabase.ler()).thenAnswer((_) async => 25);
    Contador contador = Contador();
    expect(contador.valor, 0, reason: "Contador deve iniciar em zero.");
    await contador.lerDoBanco(mockContadorDatabase);
    expect(
      contador.valor,
      25,
      reason: "Contador deve ter atualizado valor com dado do banco.",
    );
  });
});

class ContadorScreen extends StatefulWidget {
  const ContadorScreen({super.key});
  @override
  State<ContadorScreen> createState() => _ContadorScreenState();
}
class _ContadorScreenState extends State<ContadorScreen> {
  Contador contador = Contador();
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          const Text(
            "O mais SIMPLES dos\ncontadores",
            textAlign: TextAlign.center,
            style: TextStyle(fontSize: 32, fontWeight: FontWeight.bold),
          ),
          const SizedBox(height: 32),
          Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            crossAxisAlignment: CrossAxisAlignment.center,
            children: [
              ElevatedButton(
                onPressed: () {
                  setState(() {
                    contador.decrementar();
                  });
                },
                child: const Text("-"),
              ),
              Text(
                "${contador.valor}",
                style: const TextStyle(fontSize: 24),
              ),
              ElevatedButton(
                onPressed: () {
                  setState(() {
                    contador.incrementar();
                  });
                },
                child: const Text("+"),
              ),
            ],
          ),
        ],
      ),
    );
  }
}

import 'package:flutter_test/flutter_test.dart';
import 'package:flutter/material.dart';
import 'package:flutter_testes_estudo/screens/contador_screen.dart';
void main() {
  testWidgets("O título da aplicação é mostrado na tela.", (widgetTester) async {
    await widgetTester.pumpWidget(
      const MaterialApp(
        home: ContadorScreen(),
      ),
    );
    final Finder titleFinder = find.text("O mais SIMPLES dos\ncontadores");
    expect(titleFinder, findsOneWidget);
  });
}

testWidgets("O botão de incrementar deve somar 1 no contador.",
      (widgetTester) async {
  await widgetTester.pumpWidget(const MaterialApp(home: ContadorScreen()));
  expect(
    find.text("1"),
    findsNothing,
    reason: "Pois a tela deve estar mostrando '0' ao iniciar.",
  );
  final Finder addButtonFinder = find.text("+");
  await widgetTester.tap(addButtonFinder);
  await widgetTester.pumpAndSettle();
  expect(
    find.text("1"),
    findsOneWidget,
    reason: "Pois a tela deve agora mostrar '1'.",
  );
});

class Pessoa {
  final String nome;
  final int idade;
  Pessoa(this.nome, this.idade)
      : assert(nome.isEmpty, 'O nome não pode ser vazio'),
        assert(idade >= 0, 'A idade não pode ser negativa');
}
void main() {
  // Criando uma instância de Pessoa
  Pessoa pessoa = Pessoa('João', 30);
  print('Nome: ${pessoa.nome}, Idade: ${pessoa.idade}');
  // Tentando criar uma Pessoa com nome nulo
  Pessoa pessoaComNomeVazio =
      Pessoa("", 25); // Isso lançará uma exceção AssertionError
}

group("Método 'adicionarDoTeclado':", () {
  test("Se tudo der certo, o retorno deve ser nulo.", () {
    Contador contador = Contador();
    expect(contador.adicionarDoTeclado("5"), isNull);
  });
  test(
      "Se o teclado enviar um valor não numérico, deve-se retornar uma mensagem de erro.",
      () {
    Contador contador = Contador();
    expect(
        contador.adicionarDoTeclado("Cinco"), equals("Valor não numérico."));
  });
  test(
      "Se o teclado enviar um valor fracionado, deve-se adicionar apenas o chão inteiro.",
      () {
    Contador contador = Contador();
    contador.adicionarDoTeclado("5.5");
    expect(contador.valor, equals(5));
  });
});

String? adicionarDoTeclado(String novoValor) {
    double? valorDouble = double.tryParse(novoValor);
    if (valorDouble != null) {
      valor = valorDouble.floor();
      return null;
    }
    return "Valor não numérico.";
}

Código mais confiável: Ao escrever testes automatizados antes de implementar o código de produção, garante-se que cada funcionalidade seja testada em detalhes. Isso resulta em um código mais confiável, com menos bugs e comportamentos inesperados.
Feedback rápido: O ciclo "Red-Green-Refactor" do TDD proporciona um feedback rápido sobre a implementação do código. Os testes falham inicialmente (Red), mas passam assim que a funcionalidade é implementada corretamente (Green). Esse ciclo rápido ajuda pessoas desenvolvedoras a identificarem problemas e corrigi-los prontamente.
Documentação viva: Os testes servem como documentação viva do código, descrevendo o comportamento esperado das funcionalidades. Isso facilita a compreensão do código por parte dos(as) desenvolvedores(as), especialmente em projetos colaborativos ou durante a manutenção do código no futuro.
Facilita a refatoração: Como os testes garantem que o comportamento do código não seja alterado inadvertidamente, eles permitem que os(as) desenvolvedores(as) realizem refatorações com confiança. Isso significa que o código pode ser reestruturado e otimizado sem medo de introduzir regressões.
Promove o design modular: O TDD incentiva o desenvolvimento de código modular, onde as funcionalidades são divididas em unidades independentes e testáveis. Isso facilita a manutenção do código e a reutilização de componentes em diferentes partes do projeto.
Reduz o tempo de depuração: Como os testes são executados automaticamente, os problemas são identificados precocemente, reduzindo a necessidade de depuração manual intensiva. Isso economiza tempo e recursos durante o ciclo de desenvolvimento.
Maior confiança nas mudanças: Com uma suíte de testes abrangente, os(as) desenvolvedores(as) têm mais confiança ao introduzir novas funcionalidades ou realizar alterações no código existente. Eles(as) podem ter certeza de que as alterações não afetarão negativamente outras partes do sistema.

Ricarth Lima

Inscreva-se em nossa Newsletter

Explore por tópico

Quando usar testes?

Para quê servem os testes?

O que são testes?

Três categorias de testes no Flutter

Confiabilidade

Custo de manutenção

Dependências

Velocidade de execução

Como configurar o ambiente de testes de unidade

Fundamentos de testes de unidade no Flutter

Criando uma classe para testar

Escrevendo nosso primeiro teste

Rodando nosso primeiro teste

Princípio da independência entre os testes de unidade

Explorando expect e matcher

Debulhando o expect

Considerando outros tipos de matcher

Esperando por exceções

Como simular dependências externas com mocks e stubs

Quando usar dublês

Tipos de dublês

Instalando o Mockito

Criando mocks

Aplicando os mocks

Utilizando Stubs

Testando widgets

Teste de widgets com finder

Simulando ações da pessoa usuária

Conhecendo os testes de integração

Conhecendo os asserts

Conhecendo o TDD e como ele se aplica ao Flutter

E o que o Flutter tem a ver com isso?

Integração Contínua no Testes com Flutter

Como aprender mais sobre Flutter

Conclusão

Referências

Leia também

Explorando `expect` e `matcher`

Debulhando o `expect`

Considerando outros tipos de `matcher`

Conhecendo os `asserts`