Introdução ao teste de unidade do .NET usando o NUnit

Testes de unidade automatizados durante o desenvolvimento de seu código são considerados uma boa prática. Isso ajuda você a encontrar bugs no início do ciclo de desenvolvimento e economiza tempo a longo prazo. O desenvolvedor pode executar esses testes várias vezes para verificar o comportamento de uma unidade de código específica para diferentes conjuntos de entrada.

Os testes de unidade verificam essencialmente o comportamento de uma unidade específica do código ou da função e são escritos pelos desenvolvedores que estão implementando as funcionalidades.

Testamos o comportamento de uma função antes que ela se torne parte de todo o sistema e entre em produção escrevendo um pedaço de código para testar esse comportamento em diferentes condições. Normalmente, uma função é testada isoladamente com as outras funções do sistema em teste (SUT).

No .NET, há duas opções para escrever testes de unidade:

1. Usando o teste MS
2. Using NUnit

Neste artigo, aprenderemos a iniciar o teste de unidade de classes C# usando NUnit. Vamos percorrer:

• Criando o sistema em teste
• Setting up NUnit
• Criando o projeto de teste
• Criando classes e métodos de teste
• Diferentes opções para executar os testes
• Understanding TestFixtures and TestTearDown
• Trabalhando com o teste Ignorar

System Under Test

Neste exemplo, vamos escrever um teste de unidade para um sistema de calculadora. Digamos que a interface da Calculadora seja definida conforme mostrado na listagem abaixo:

namespace Calculator
{
   public interface ICalculator
    {
       int Add(int num1, int num2);
       int Mul(int num1, int num2);
    }
}

A classe Calculator é implementada conforme mostrado na listagem abaixo:

namespace Calculator
{
  public class Calculator :ICalculator
    {
 
        public int Add(int num1, int num2)
        {
            int result = num1 + num2;
            return result;
        }
 
        public int Mul(int num1, int num2)
        {
            int result = num1 + num2;
            return result;
        }
    }
}

Você notará que implementamos a função Mul incorretamente de propósito.

Para começar a trabalhar com o NUnit e escrever o teste, precisamos seguir os seguintes passos:

1. Criar um projeto de teste
2. Adicionar uma referência à biblioteca NUnit
3. Adicionar uma referência ao sistema no projeto de teste
4. Crie uma classe de teste e escreva o método de teste

Configurando o projeto de teste

Para criar um projeto de teste, adicione um projeto de biblioteca de classes, conforme mostrado na listagem abaixo. Normalmente, devemos seguir a convenção de nomenclatura para nomear o projeto de teste como ProjectUnderTest.Test. Aqui vamos testar o projeto Calculadora, então o nome do projeto de teste deve ser Calculator.Test.

Depois que um projeto de teste é criado, você tem duas opções para adicionar uma referência ao NUnit no projeto:

1. Usando a extensão e as atualizações
2. Usando o pacote NuGet

Para trabalhar com extensões e atualizações, clique em Tool->Extension and Updates e selecione NUnit Test Adapter.

Para trabalhar com o pacote NuGet, clique com o botão direito do mouse no projeto e, no menu de contexto, selecione a opção Gerenciar pacotes NuGet. No gerenciador de pacotes NuGet, pesquise o NUnit e instale o Adaptador de Teste NUnit para VS e NUnit no projeto, conforme mostrado na imagem abaixo:

Depois de instalar o adaptador de teste NUnit, podemos trabalhar com o NUnit.

Adicionar uma referência ao sistema no projeto de teste

Em seguida, precisamos adicionar uma referência ao projeto Calculadora (sistema em teste) no projeto de teste. Para adicionar isso, clique com o botão direito do mouse no projeto de teste e adicione uma referência ao projeto da Calculadora.

Criar classe de teste e métodos de teste

Antes de prosseguirmos e criarmos uma classe de teste e métodos de teste, vamos entender a estrutura do projeto de teste. Como o nome do nosso projeto SUT é Calculator, devemos nomear o projeto de teste como Calculator.Tests. O nome da classe no teste é Calculator, portanto, o nome do teste deve ser CalculatorTest. Finalmente, o nome da função de teste deve ser o nome da função sob o teste, precedido pela palavra "deveria". A ideia aqui é dar um nome legível ao projeto, classe e função de teste.

A relação entre o projeto SUT e o projeto de teste pode ser representada conforme mostrado na imagem abaixo:

Em seguida, vamos criar a classe de teste e os métodos de teste.  Precisamos usar:

1. Atributo TestFixture para criar a classe de teste
2. Atributo de teste para criar o método de teste

Uma classe de teste pode ser criada conforme mostrado na listagem abaixo:

using NUnit.Framework;
 
namespace Calculator.Tests
{
   [TestFixture]
   public class CalculatorTest
    {
       [Test]
       public void ShouldAddTwoNumbers()
       {
           ICalculator sut = new Calculator();
           int expectedResult = sut.Add(7, 8);
           Assert.That(expectedResult, Is.EqualTo(15));
       }
 
       [Test]
       public void ShouldMulTwoNumbers()
       {
           ICalculator sut = new Calculator();
           int expectedResult = sut.Mul(7, 8);
           Assert.That(expectedResult, Is.EqualTo(56));
       }
 
    }
}

Na lista acima, estamos:

1. Criando um objeto da classe SUT Calculator
2. Chamando os métodos
3. Afirmando o resultado usando NUnit assert (falaremos mais sobre asserting em posts posteriores)

Depois de criar o projeto de teste, precisamos executar o teste.

Executando o teste

Há três opções para executar o teste:

1. Usando o Gerenciador de Testes do Visual Studio
2. Usando a GUI do NUnit
3. Usando o prompt de comando do NUnit

Visual Studio Test Explorer

Para usar o Visual Studio Test Runner, inicie o Gerenciador de Testes clicando na opção TEST-WINDOWS-TEST EXPLORER, conforme mostrado na imagem abaixo:

Você deve conseguir ver o teste de unidade listado no Gerenciador de Testes. Você pode selecionar um teste específico e executá-lo ou optar por executar todos os testes. Após executar os testes do projeto Calculator.Tests, no Gerenciador de Testes, o resultado pode ser visto como mostra a imagem abaixo. Podemos ver que o teste ShouldAddTwoNumbers foi aprovado, enquanto o teste ShouldMulTwoNumbers falhou (o que é esperado).

NUnit GUI

Você pode baixar o MSI da GUI do NUnit aqui. Uma vez baixado, instale a GUI do NUnit e, no menu Arquivo, selecione a opção Abrir Projeto e adicione DLL ao projeto Calculator.Test. Depois de adicionar a DLL, você poderá ver os testes carregados na interface do usuário. Para executar um teste, selecione e clique em Executar. Na interface do usuário do NUnit, você pode ver claramente a mensagem do teste com falha.

Prompt de comando do NUnit

Sua terceira opção para executar o teste é usando o prompt de comando do NUnit. Navegue até a pasta NUnit\Bin nos Arquivos de Programas (sua localização depende do caminho de instalação selecionado) e execute o arquivo nunit-console.exe. Nas aspas duplas, você precisa passar o caminho completo da dll do projeto de teste como o segundo parâmetro para executar o teste, conforme mostrado na imagem abaixo:

A opção de prompt de comando NUnit é muito útil para a integração contínua.

TestFixtureSetUp e TestFixtureTearDown

Dois conceitos muito importantes do teste NUnit são Configuração de Teste e Desmontagem. No Calculator.Test, estamos criando objetos da Calculadora SUT em ambos os testes. Esta não é a prática correta. Devemos criar todos os objetos necessários para o teste antes da execução de qualquer teste. Outros cenários podem ser:

1. Crie uma conexão de banco de dados antes da execução do primeiro teste
2. Crie uma instância de um objeto específico antes da execução do primeiro teste
3. Excluir toda a conexão com o banco de dados após a execução de todos os testes
4. Exclua um arquivo específico do sistema antes da execução de qualquer teste

Podemos resolver os cenários acima usando o TestFixtureSetUp e o TestFixtureTearDown. TestFixtureSetUp é um código que é executado antes da execução de qualquer teste, e o TestFixtureTearDown é um pedaço de código que é executado após a execução de todos os testes.

Vamos considerar Calculator.Test. Em ambos os testes, estamos criando um objeto da Calculadora SUT. Considerando que precisamos de um objeto da classe Calculator antes da execução de qualquer teste e precisamos descartá-lo após a execução de todos os testes. Podemos modificar a classe de teste como com SetUp e TearDown, conforme mostrado na listagem abaixo:

using NUnit.Framework;
 
namespace Calculator.Tests
{
 
   [TestFixture]
   public class CalculatorTest
    {
       ICalculator sut;
       [TestFixtureSetUp]
       public void TestSetup()
       {
           sut = new Calculator();
       }
       [Test]
       public void ShouldAddTwoNumbers()
       {
          
           int expectedResult = sut.Add(7, 8);
           Assert.That(expectedResult, Is.EqualTo(15));
       }
       [Test]
       public void ShouldMulTwoNumbers()
       {
        
           int expectedResult = sut.Mul(7, 8);
           Assert.That(expectedResult, Is.EqualTo(56));
       }
 
       [TestFixtureTearDown]
       public void TestTearDown()
       {
           sut = null;
       }
 
    }
}

Na lista acima, você notará:

1. Há uma função atribuída com [TestFixtureSetUp]. Esta função será executada antes da execução de qualquer teste. Estamos criando um objeto da Calculadora SUT dentro desta função de forma que a instância criada esteja disponível para todos os testes.
2. Há uma função atribuída com [TestFixtureTearDown]. Esta função será executada após a execução de todos os testes. Estamos descartando o objeto da Calculadora SUT dentro desta função.

Ignorar teste

Outro cenário que você pode encontrar ao executar um teste é que você pode querer ignorar determinados testes a serem executados. Por exemplo, há três testes e você deseja que um deles seja ignorado durante a execução do restante de seus testes. Isso pode ser feito atribuindo o teste a ser ignorado com o atributo [ignore].​

Um teste pode ser ignorado, conforme mostrado na listagem abaixo:

 [Test]
       [Ignore]
       public void ShouldNotMulTwoNumbers()
       {
 
           int expectedResult = sut.Mul(7, 8);
           Assert.That(expectedResult, Is.EqualTo(15));
       }

Ao executar todos os testes no gerenciador de testes, para o teste ignorado, você receberá a mensagem conforme mostrado na imagem abaixo:

Conclusão

Neste artigo, começamos a fazer o Teste de Unidade usando o NUnit no .NET. Aprendemos sobre vários componentes do teste de unidade usando o NUnit, conforme mostrado nos pontos abaixo:

• Criando o sistema em teste
• Setting up NUnit
• Criando o projeto de teste
• Criando classes e métodos de teste
• Diferentes opções para executar os testes
• Understanding TestFixtures and TestTearDown
• Trabalhando com o teste Ignorar

Espero que este artigo o ajude a começar a testar a unidade - obrigado por ler e Happy Coding!