Como escrever testes de unidade para um aplicativo .NET Core

Na abordagem TDD, antes de implementar uma funcionalidade, você escreve um teste de unidade para ela. Por exemplo, se você quiser escrever uma função para adicionar dois números, primeiro você escreverá um teste de unidade com falha e, em seguida, implementará a funcionalidade para passar no teste.

Neste post, criaremos um aplicativo de calculadora. Para começar, vamos seguir a estrutura de pastas conforme descrito abaixo:

• CalculatorApp – Solution
• CalculatorApp.Services – Application project
• CalculatorApp.Services.Tests – Projeto de teste

Você pode usar o Visual Studio para criar projetos; no entanto, neste post, usarei comandos do .NET Core para criar meus projetos, adicionar testes e executar testes. Você também pode usar MSTest ou NUnit para escrever testes de unidade, mas neste exemplo, usarei xUnit e dotnet test para escrever e executar meus testes de unidade.

Vamos começar abrindo um shell de comando e acompanhar:

Criando o projeto de aplicativo

Para começar, você precisará criar um diretório chamado CalculatorApp. Lembre-se de que você pode seguir qualquer convenção de nomenclatura que desejar para diretórios, mas se quiser acompanhar esta postagem, recomendo seguir o mesmo nome de diretório. Então, vamos criar o diretório CalculatorApp e navegar até ele.

Dentro do diretório CalculatorApp, vamos criar uma nova solução executando o seguinte comando:

dotnet new sln

Depois de executar o comando com êxito, você deve receber a mensagem "O arquivo de solução de modelo foi criado com êxito".  Também dentro do diretório CalculatorApp, você encontrará um arquivo chamado calculatorapp.sln.

Em seguida, crie um diretório chamado CalculatorApp.Services. Este diretório manterá as fontes do aplicativo, ou seja, todas as classes do aplicativo da calculadora. Navegue até o diretório Calculatorapp.Services e crie uma biblioteca de classes executando o seguinte comando:

dotnet new classlib

Depois de executar este comando com êxito, você deve receber a mensagem "A Biblioteca de Classes de Modelo foi criada com sucesso". Você também encontrará um arquivo chamado calculatorapp.services.csproj dentro do diretório CalculatorApp.Services. Em seguida, você precisa adicionar esse projeto de biblioteca de classes à solução calculatorapp. Para fazer isso, navegue de volta para o diretório calculatorapp e execute o comando:

dotnet sln add .\calculatorapp.services\calculatorapp.services.csproj

Depois de executar o comando com êxito, você deve receber a mensagem "Projeto adicionado à solução".

Dentro da pasta CalculatorApp.Services, você encontrará uma classe Class1– renomeie-a para Calculator e modifique a classe conforme mostrado na lista abaixo:

Calculator.cs

using System;
namespace calculatorapp.services {
    public class Calculator {
        public int Add(int num1, int num2) {
            throw new NotImplementedException();
        }
        public int Sub(int num1, int num2) {
            throw new NotImplementedException();
        }
    }
}

Você notará na listagem acima que as funções Adicionar e Sub não estão implementadas. Primeiro, escreveremos um teste de unidade e, em seguida, implementaremos essas funcionalidades.

Criando o projeto de teste

Para adicionar projetos de teste, crie um diretório chamado CalculatorApp.Services.Tests e navegue até o diretório. Neste diretório, criaremos um projeto MS Test executando o seguinte comando:

dotnet new mstest

Este comando cria o projeto de teste que usa o MS Test como a biblioteca de teste.  Depois que o projeto de teste for criado, adicione a biblioteca de projetos de origem no projeto de teste. Para fazer isso, execute o comando:

dotnet add reference .. /CalculatorApp.Services/CalculatorApp.Services.csproj

 Esse comando adicionará uma referência do projeto CalculatorAppService ao projeto de teste. Depois de adicionar a referência, adicione o projeto de teste à solução navegando até o diretório raiz calculatorapp e execute o comando:

dotnet sln add .\CalculatorAppServices.tests\CalculatorAppServices.Tests.csproj

Esse comando adicionará o projeto de teste à solução. Depois de executar o comando com êxito, você deve receber a mensagem "Projeto adicionado à solução".

Writing Unit Tests

Até agora, criamos o projeto de origem do aplicativo e um projeto de teste. No projeto de origem do aplicativo, há funções não implementadas. Agora vamos escrever testes para essas funções.

No projeto Test, renomeei o arquivo UnitTest1.cs para Calculator.Test.cs e o nome da classe para CalculatorTest. No construtor de CalculatorTest, precisamos criar um objeto da classe Calculator. Isso pode ser feito conforme mostrado na lista abaixo:

Calculator.Test.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using calculatorapp.services;
namespace CalculatorApp.Services.Tests {
    [TestClass]
    public class CalculatorTest {
        Calculator _calc;
        public CalculatorTest() {
            _calc = new Calculator();
        }
    }
}

Teste de unidade para adicionar função

Na classe CalculatorTest, adicione um método de teste de unidade para testar a funcionalidade de adição, conforme mostrado na listagem abaixo:

[TestMethod]
public void shouldaddtwonumbers() {
    int res = _calc.Add(5, 3);
    Assert.AreEqual(res, 8);
}

Para executar o teste, navegue até o diretório CalculatorApp.Services.Tests e execute o comando:

dotnet test 

Você obterá uma saída de 'falha no teste' porque a função Add não está implementada, conforme mostrado na imagem abaixo:

Para passar no teste, implemente a função Add na classe Calculator, conforme mostrado na listagem abaixo:

public int Add(int num1, int num2) {
    int result = num1 + num2;
    return result;
}

Para executar o teste agora, navegue até o diretor CalculatorApp.Services.Tests e execute o comando:

dotnet test 

Como saída, você receberá a mensagem 'teste aprovado', conforme mostrado na imagem abaixo:

Agora você implementou a funcionalidade Adicionar ao aderir à abordagem TDD em um aplicativo .NET Core!

Teste de unidade para subfunção

Na classe CalculatorTest, adicione um método de teste de unidade para testar a subfuncionalidade, conforme mostrado na listagem abaixo:

[TestMethod]
public void shouldsubstracttwonumbers() {
    int res = _calc.Sub(5, 3);
    Assert.AreEqual(res, 2);
}

Para executar o teste, navegue até o diretório CalculatorApp.Services.Tests e execute o comando:

dotnet test 

Aqui, seu teste falhará porque a função Sub não foi implementada. Você obterá um resultado de teste com falha, conforme mostrado na imagem abaixo:

Para passar no teste, implemente a função Sub na classe Calculator, conforme mostrado na listagem abaixo:

public int Sub(int num1, int num2) {
    int result = num1 - num2;
    return result;
}

Agora, execute o teste novamente navegando até o diretório CalculatorApp.Services.Tests e executando:

dotnet test

Agora você verá que os dois testes foram aprovados, como visto aqui:

Agora você implementou a funcionalidade Sub ao aderir à abordagem TDD em um aplicativo .NET Core.

Conclusão

Até agora, nesta postagem, criamos um aplicativo de calculadora do .NET Core enquanto aderimos à abordagem TDD. Para criar testes, usamos os testes XUnit e dotnet. Para sua referência, aqui está o código-fonte da classe Calculator e sua classe de teste:

Calculator.cs

using System;
namespace calculatorapp.services {
    public class Calculator {
        public int Add(int num1, int num2) {
            int result = num1 + num2;
            return result;
        }
        public int Sub(int num1, int num2) {
            int result = num1 - num2;
            return result;
        }
    }
}

Calculator.test.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using calculatorapp.services;
namespace CalculatorApp.Services.Tests {
    [TestClass]
    public class CalculatorTest {
        Calculator _calc;
        public CalculatorTest() {
                _calc = new Calculator();
            }
            [TestMethod]
        public void shouldaddtwonumbers() {
                int res = _calc.Add(5, 3);
                Assert.AreEqual(res, 8);
            }
            [TestMethod]
        public void shouldsubstracttwonumbers() {
            int res = _calc.Sub(5, 3);
            Assert.AreEqual(res, 2);
        }
    }
}

E é assim que você escreve testes de unidade e depois implementa suas funcionalidades. Espero que esta postagem ajude você a começar a escrever testes de unidade para seu próximo aplicativo .NET Core!