Testes em .NET: criando testes de unidade com xUnit

Iniciando com testes - Apresentação

Olá, estudante! Eu sou a Jeniffer Bittencourt, instrutora na escola de Programação, mas se preferir, pode me chamar de Jeni. Estou aqui para te dar boas-vindas ao curso de testes em .NET.

Audiodescrição: Jeniffer se descreve como uma mulher branca, com cabelos ondulados de altura mediana pintados de azul-turquesa, e olhos castanho-escuros. Ela usa óculos de grau de armação redonda preta, veste uma blusa azul-marinho da Alura, e está em um cenário com iluminação azul e rosa ao fundo e duas estantes claras com objetos de decoração à direita da instrutora.

O que vamos aprender?

Neste curso, vamos conhecer e aplicar os fundamentos de teste de unidade, utilizando a biblioteca xUnit. Também aprenderemos a aplicar automação nos testes, entenderemos sobre padrões de escritas de testes, como o AAA e também padrões de nomenclatura.

Além disso, aplicaremos a estratégia de TDD no projeto, ampliaremos a cobertura de testes utilizando testes de mutação, e testaremos cenários complexos trabalhando com dados fakes (falsos) nos testes.

O projeto que vamos utilizar para aprender isso tudo é o Jornada Milhas. O Jornada Milhas é uma aplicação onde conseguimos cadastrar e exibir ofertas de viagem.

O projeto inicial necessário para trabalharmos durante este curso está disponível na atividade Preparando o ambiente para você fazer o download.

Para quem é o curso?

Este curso é para você que quer aprofundar seus conhecimentos e conhecer bibliotecas e práticas de testes automatizados que são bastante utilizadas no mercado.

Para maior aproveitamento do conteúdo que vamos abordar, é importante ter conhecimento em orientação a objetos e tenha feito duas formações da Alura:

• Aprenda a programar em C# com Orientação a Objetos
• C# Web: crie aplicações usando ASP.NET.

Conclusão

Antes de prosseguir para o próximo vídeo, temos um recado muito importante para você: os cursos na plataforma da Alura são divididos em várias atividades.

Temos as videoaulas que você já conhece, as atividades em texto para aprofundamento em conhecimentos específicos, as atividades de alternativa que ajudam a reforçar o que aprendemos, e as atividades práticas que vão ajudar a aplicar todos os conceitos que aprenderemos neste curso.

Portanto, é muito importante fazer todas essas atividades, pois é assim que você irá reforçar tudo o que está aprendendo e colocar em prática.

Para te ajudar a concluir essa jornada, conte também com o suporte no fórum e o apoio da comunidade no Discord, onde você pode tirar suas dúvidas e compartilhar seu conhecimento.

Pegue um café, uma água, se acomode na cadeira e bons estudos!

Iniciando com testes - Automatizando testes

O projeto em que vamos trabalhar é o Jornada Milhas, uma aplicação onde são exibidas ofertas de viagem. Nosso foco durante este curso será a parte administrativa, onde essas ofertas são cadastradas. O projeto está disponível para download na atividade Preparando o ambiente.

Ao explorar o projeto do Jornada Milhas, encontramos a parte do menu (ExibirMenu()) onde as ofertas são cadastradas, as classes de modelo de oferta de viagem (OfertaViagem.cs), período (Periodo.cs), rota (Rota.cs), e também a classe de validação (Valida.cs).

Nossa tarefa é preparar essa aplicação para rodar sem erros, ou pelo menos minimizar a chance de erros para a pessoa usuária final, que é quem vai cadastrar as ofertas.

Para fazer isso, entramos em um conceito muito importante do processo de desenvolvimento de software: os testes. Como poderíamos testar a aplicação do Jornada Milhas?

Automatizando testes

A primeira ideia que vem à mente é fazer o teste manual que já fazemos quando escrevemos o código, que seria executar a aplicação e fazer um cadastro de oferta manualmente, seguindo o processo que a pessoa usuária final já seguiria.

No entanto, testes manuais são responsabilidade de uma pessoa e, além de ser um processo repetitivo, ainda traz a possibilidade de erros, pois essa pessoa pode esquecer alguma informação ou de testar algum cenário. Portanto, para o contexto de testes, trabalhar com testes manuais não seria o ideal.

Para resolver essa questão, podemos trabalhar com os testes automatizados, que basicamente é escrever código para testar. Porém, antes de começarmos efetivamente a aplicar os testes automatizados no Jornada Milhas, precisamos preparar todo o cenário para depois podermos utilizar os testes.

Preparando o cenário

Primeiramente, vamos acessar a aba "Gerenciador de Soluções", à esquerda no Visual Studio. Vamos clicar com o botão direito sobre "Solução 'Jornada Milhas'" e selecionar "Adicionar > Novo Projeto…".

Na barra de pesquisa, vamos digitar "teste" e vão aparecer vários modelos de projeto de teste. O que vamos localizar nessa lista será o "Projeto de Teste do xUnit", biblioteca que vamos utilizar para nos auxiliar nos processos de teste.

Após selecionar essa opção, vamos clicar em "Próximo" no canto inferior direito. O nome do projeto seguirá um padrão de nomenclatura geralmente utilizado: JornadaMilhas.Test.

Em "Local", vamos selecionar dentro da pasta do projeto uma subpasta chamada "tests". Feito isso, basta clicar em "Selecionar pasta" e depois em "Próximo > Criar".

Assim, teremos um novo projeto dentro da nossa solução. Se visualizarmos o Gerenciador de Soluções, agora temos o projeto JornadaMilhas, no qual trabalhamos anteriormente, e o projeto novo JornadaMilhas.Test, no qual vamos trabalhar para fazer os testes a partir de agora.

Explorando o projeto JornadaMilhas.Test

Se investigarmos o projeto JornadaMilhas.Test, no diretório "Dependências > Pacotes", percebemos que ele já trouxe instalado o pacote xunit (2.4.2), que é o que vamos utilizar, ou seja, não precisamos fazer nenhuma configuração adicional.

Além disso, se continuarmos verificando o que veio nesse pacote, vamos nos deparar com uma classe chamada UnitTeste1. Abrindo essa classe, temos uma classe pública (public class) que também tem um método público (public void) chamado Test1(), e esse projeto tem uma anotação [Fact].

UnitTest1.cs:

namespace JornadaMilhas.Test;

public class UnitTest1
{
    [Fact]
    public void Test1()
    {
    
    }
}

Executando a classe de teste

Agora vamos executar essa classe de teste para verificar o que acontece e entender melhor como ela funciona. Para isso, clicamos com o botão direito sobre o código e selecionamos "Executar e Testar".

Após a execução, na lateral esquerda do Visual Studio, surgirá uma janela chamada "Gerenciador de Testes". É nessa janela que vamos conseguir gerenciar o status do nosso teste.

Se expandirmos JornadaMilhas.Test até o último nível, vamos identificar o nome da classe, isto é, UnitTest1, e logo abaixo, o nome do método de teste (Test1).

No nosso caso, todos os testes foram aprovados, porque não temos nenhum código de teste no momento. Se algum desses testes não tivesse passado, ficaria um símbolo vermelho com um "X".

A partir disso, conseguimos perceber que a anotação [Fact] sinaliza que o método Test1() será um método de teste. Assim, ele consegue ser identificado pelo Gerenciador de Testes.

Conclusão

Com isso, temos o projeto preparado para começar a trabalhar com testes automatizados e entender como eles podem ajudar na estrutura de testes. Também já temos a biblioteca que iremos utilizar instalada no projeto: a xUnit.

No próximo vídeo, vamos continuar entendendo melhor como trabalhar com os testes automatizados e criaremos efetivamente o nosso primeiro teste. Até lá!

Iniciando com testes - Começando com XUnit

Estamos no processo de começar a escrever nossos testes automatizados, mas temos bastante informação no projeto Jornada Milhas. Por onde podemos começar a fazer esses testes?

Começando com xUnit

Neste momento, sugerimos começar olhando para o arquivo OfertaViagem.cs, que é a classe de modelo principal da estrutura do Jornada Milhas. Nesse arquivo, temos alguns métodos:

• O construtor OfertaViagem();
• O ToString();
• E o método de validação Validar().

Testando a estrutura do construtor

Para começarmos a fazer nossos testes e entender melhor como vai funcionar, podemos pegar a estrutura do construtor. Portanto, começaremos testando a estrutura de construção do objeto OfertaViagem.

OfertaViagem.cs:

// código omitido

public OfertaViagem(Rota rota, Periodo periodo, double preco)
{
    Rota = rota;
    Periodo = periodo;
    Preco = preco;
    Validar();
}

// código omitido

Renomeando a classe de teste

Agora que escolhemos qual parte começaremos a testar, vamos voltar ao projeto de testes. A primeira coisa que vamos fazer é renomear a classe de teste, porque o nome UnitTest1.cs que ele traz por padrão não referencia muita coisa, ou seja, quando olhamos para ele, não faz muito sentido.

Precisamos contextualizar melhor, então vamos renomear a classe de teste clicando com o botão direito sobre ela e selecionando a opção "Renomear". Chamaremos ela de OfertaViagemTest.cs.

Refatorando a classe de teste

Feito isso, saberemos que essa classe de teste se referencia a OfertaViagem. Na classe OfertaViagemTest, podemos renomear também o método de teste. Queremos testar se é gerada uma oferta válida pelo construtor, então vamos chamar o método de TestandoOfertaValida().

OfertaViagemTest.cs:

namespace JornadaMilhas.Test;

public class OfertaViagemTest
{
    [Fact]
    public void TestandoOfertaValida()
    {

    }
}

Construindo um novo objeto

Para começarmos a escrever o teste e testar efetivamente o construtor, precisamos construir um novo objeto. Sendo assim, podemos começar a trazer as informações necessárias para isso.

Primeiramente, precisaremos de uma rota, então vamos digitar Rota rota na linha 8 e atribuir new Rota. Ao começar a escrever Rota, percebemos que o Visual Studio não consegue identificar o que é esse tipo. Isso acontece porque precisamos trazer a referência de projeto quando trabalhamos com dois projetos diferentes dentro da mesma solução.

Dito isso, precisamos clicar com o botão direito sobre o projeto de teste JornadaMilhas.Test, e ir até "Adicionar > Referência de Projeto…". Na janela aberta, vamos sinalizar que queremos que ele tenha o projeto base como referência, então marcaremos JornadaMilhas e clicaremos em "OK".

A partir de agora, se posicionarmos o cursor sobre Rota, que está com marcação de erro, e clicarmos em "Mostrar possíveis correções", ele sugere utilizar o modelo JornadaMilhasV1.Modelos.

using JornadaMilhasV1.Modelos;

namespace JornadaMilhas.Test;

public class OfertaViagemTest
{
    [Fact]
    public void TestandoOfertaValida()
    {
        Rota rota = new Rota();
    }
}

Dando continuidade à construção da Rota, vamos passar os valores entre parênteses. Precisamos passar a origem e o destino, então digitaremos "OrigemTeste" e "DestinoTeste".

O próximo item que precisamos passar é o período, então na linha 11, definiremos Periodo como periodo, e atribuiremos new Periodo(), recebendo a data de início e a data final. Nesse caso, traremos new DateTime(2024, 2, 1) como data inicial e new DateTime(2024, 2, 5) como data final.

Na sequência, o item que precisamos para construir uma oferta de viagem é o preço. Nesse caso, teremos um double preco que será de 100 reais (100.0).

Nesse teste, queremos verificar se ele está válido. Portanto, podemos também criar uma variável, que chamaremos de validacao, e ela deverá ser verdadeira, ou seja, true.

using JornadaMilhasV1.Modelos;

namespace JornadaMilhas.Test;

public class OfertaViagemTest
{
    [Fact]
    public void TestandoOfertaValida()
    {
        Rota rota = new Rota("OrigemTeste", "DestinoTeste");
        Periodo periodo = new Periodo(new DateTime(2024, 2, 1), new DateTime(2024, 2, 5));
        double preco = 100.0;
        var validacao = true;
    }
}

Com isso, já temos os itens necessários para construir a oferta de viagem, então vamos fazer isso efetivamente: na linha 15, teremos uma OfertaViagem que se chamará oferta.

Após =, vamos passar os atributos que acabamos de criar. Dessa forma, vamos adicionar new OfertaViagem() recebendo entre parênteses rota, periodo e preco.

Validando o novo objeto

Agora precisamos validar esse objeto e verificar se ele está válido. Para fazer isso, vamos utilizar um item do próprio xUnit: o Assert.

O Assert traz vários métodos, inclusive, aparece uma lista suspensa com sugestões referenciadas pelo Visual Studio. São vários os métodos que conseguiremos utilizar para fazer essa validação.

O que vamos utilizar nesse momento é o Equal(). O método Equal() receberá dois parâmetros: o parâmetro esperado e o parâmetro que deve ser verificado. Qual é o parâmetro esperado?

O parâmetro esperado é validacao, a qual queremos que seja verdadeira. Já o parâmetro que será verificado é o próprio método de validação de OfertaViagem, então utilizaremos oferta.EhValido.

using JornadaMilhasV1.Modelos;

namespace JornadaMilhas.Test;

public class OfertaViagemTest
{
    [Fact]
    public void TestandoOfertaValida()
    {
        Rota rota = new Rota("OrigemTeste", "DestinoTeste");
        Periodo periodo = new Periodo(new DateTime(2024, 2, 1), new DateTime(2024, 2, 5));
        double preco = 100.0;
        var validacao = true;

        OfertaViagem oferta = new OfertaViagem(rota, periodo, preco);

        Assert.Equal(validacao, oferta.EhValido);
    }
}

Testando o código

Com isso, finalizamos a construção do nosso primeiro teste. Vamos executar para conferir se funciona corretamente? Para melhorar a visualização do teste, vamos mover o "Gerenciador de Testes" da lateral esquerda para a direita. Por fim, vamos ocultar o "Gerenciador de Soluções".

Feito isso, podemos executar o teste. Uma maneira de fazer isso é acessar a aba "Gerenciador de Testes" e clicar na seta verde "Executar". Após a execução, o teste passou corretamente como esperávamos.

Conclusão

Além de construir o nosso primeiro teste automatizado, aprendemos também a importância de usar a referência de projeto quando trabalhamos com projetos diferentes na mesma solução.

Conhecemos também o Assert da biblioteca xUnit, responsável por trazer métodos que ajudam a fazer as validações dos testes. Na sequência, há um material extra falando mais sobre os métodos disponíveis.

No próximo vídeo, continuaremos conhecendo mais sobre os testes e construindo novos testes para a nossa aplicação. Te esperamos lá!

Sobre o curso Testes em .NET: criando testes de unidade com xUnit

O curso Testes em .NET: criando testes de unidade com xUnit possui 105 minutos de vídeos, em um total de 59 atividades. Gostou? Conheça nossos outros cursos de .NET em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Iniciando com testes
• Validando ofertas
• TDD - Test-Driven Development
• Cobertura de testes
• Testando cenários complexos