C#  -  XUnit Básico

Neste artigo veremos um resumo básico sobre o XUnit.

A realização de testes de unidade é uma abordagem de teste de software que é executada em tempo de desenvolvimento para testar o menor componente de qualquer software.

Significa que ao invés de testar o sistema todo uma só vez, você testa pequenas partes do software. Com isso estamos nos referindo a testar funções, propriedades, métodos ou qualquer classe que esteja manipulando uma funcionalidade da aplicação.

Criar casos de teste de unidade nos ajudam a testar e descobrir se a unidade individual está executando a tarefa de uma maneira boa ou não. Eles basicamente nos garante que o sistema é projetado de acordo com os requisitos e nos ajuda a descobrir os erros antes de colocar o código real no ambiente de produção.

A seguir temos algumas das vantagens em realizar testes de unidades:

Antes de partimos para a prática vejamos algumas dicas úteis para escrever os casos de teste:

Na plataforma .NET temos 3 opções de frameworks disponíveis para realizar testes de unidade :

  1. MSTest - É o mais simples entre os três, sua utilização é bem fácil, bastando adicionar o atributo [TestClass] e [TestMethod] respectivamente nas classes e métodos para iniciar a execução dos testes, outro ponto positivo é que o Visual Studio já vem com um UI Panel para exibir os seus testes. Sem dúvida um dos seus pontos fortes é a integração com o VS e a facilidade de uso;
     
  2. NUnit - É o mais popular, sendo muito usado desde 2006, assim tornou-se referência para testes de unidades, e sem dúvida é uma excelente solução para testes. A sua instalação no projeto é via NuGet package, bastando apenas procurar por NUnit no gerenciador de pacotes. Sua implementação é bastante similar ao MSTest, sendo que [TestClass] passa a ser [TestFixture] e [TestMethod] passa a ser apenas [Test] e testes parametrizados podem ser realizados apenas adicionando [TesteCase(“seu parametro”)];
     
  3. xUnit - Nasceu a partir do NUnit. Os antigos criadores do NUnit se uniram  com o objetivo de criar um framework de testes mais flexível e abrangente. Com isso encontramos muitas semelhanças entre ambos, apesar disso também existem diversas diferenças, como por exemplo, os nomes dos atributos; no XUnit não existe a necessidade de tornar uma classe testável como no MSTest[TestClass] e NUnit[TestFixture], neste basta decorar os métodos com os atributos [Facts] e [Theory], para testar métodos sem e com parâmetros respectivamente;

Agora vejamos uma aplicação prática usando um projeto Console na linguagem C# e o framework XUnit.

XUnit - Conceitos básicos

No xUnit precisamos decorar os métodos de teste com o atributo [Fact], que é usado pelo xUnit para marcar os métodos de testes. Além dos métodos de testes, também podemos ter vários métodos auxiliares na classe de teste.

Com o XUnit para tornar um método comum em método de testes basta adicionar [Fact] ou [Theory] acima de sua assinatura, os atributos diferem apenas no seguinte, para testes sem parâmetros deve-se usar [Fact], para testes como parâmetros utiliza-se o [Theory].

O atributo [Theory] indica um teste parametrizado que é verdadeiro para um subconjunto de dados. Esses dados podem ser fornecidos de várias maneiras, mas o mais comum é com um atributo [InlineData]. Assim este atributo permite executar um método de teste várias vezes passando diferentes valores a cada vez como parâmetros.

Podemos ainda desativar um teste por qualquer motivo. Para isso basta definir a propriedade Skip no atributo Fact com o motivo que você desativou o teste (o motivo não é exibido).

        [Fact(Skip = "Teste ainda não disponível")]
        public void Teste()
        {
        }

Á medida que o número de seus testes aumenta, você pode organizá-los em grupos para que poder executar os testes juntos. O atributo [Trait] permite organizar os testes em grupos, criando nomes de categoria e atribuindo valores a eles.

        [Fact(DisplayName = "Teste Numero 2")]
        [Trait("Calculo", "Somar")]
        public void Somar_DoisNumeros_RetornaNumero()
        { }

No Test Explorer, este teste aparecerá sob o título Calculo[Somar] (cada combinação Name/Value aparece como um cabeçalho separado no Test Explorer).

Ao escrever testes unitários, em geral seguimos o princípio AAA :  Act, Arrange e Assert (Organizar, Agir e Assertir):

Arrange - É aqui que você normalmente prepara tudo para o teste, em outras palavras, prepara a cena para testar (criar os objetos e configurá-los conforme necessário)

Act - É onde o método que estamos testando será executado;

Assert - Esta é a parte final do teste em que comparamos o que esperamos que aconteça com o resultado real da execução do método de teste;

Os nomes dos métodos de teste devem ser tão descritivos quanto possível. Na maioria dos casos, é possível nomear o método para que nem seja necessário ler o código real para entender o que está sendo testado.

No exemplo, usamos a seguinte convenção de nomenclatura :

1 - A primeira parte do nome representa o nome do método que está sendo testado;
2-  A segunda parte do nome nos informa mais sobre o cenário de teste;
3-  A  última parte do nome é o resultado esperado;

Exemplo : Soma_DoisNumerosInteiros_RetornaNumeroInteiro

Temos assim uma apresentação dos principais recursos do XUnit para realização de testes de unidade.

Em outro artigo veremos como realizar testes de unidade usando o XUnit.

"Disse-lhes, pois, Jesus: Quando levantardes o Filho do homem, então conhecereis que EU SOU, e que nada faço por mim mesmo; mas isto falo como meu Pai me ensinou."
João 8:28

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?

Referências:

José Carlos Macoratti