Testes em C# (.NET): frameworks e ferramentas para o desenvolvedor

Testes em C# (.NET): visão geral de frameworks e ferramentas

Testes de qualidade são a base de um software confiável na plataforma .NET. No ecossistema C#, existem vários frameworks maduros para testes unitários, de integração e de aceitação. Neste artigo, abordaremos as principais ferramentas, suas características e daremos exemplos práticos de código.

Principais frameworks para testes unitários

No .NET Core e .NET 5+, o suporte integrado a testes é implementado através de três frameworks principais:

• MSTest — framework clássico da Microsoft, simples para iniciantes.
• NUnit — framework open-source popular com um rico conjunto de atributos.
• xUnit.net — ferramenta moderna, leve e flexível, criada pelo autor do NUnit.

Todos os três são suportados no Visual Studio, Rider e via dotnet CLI. A escolha depende das preferências da equipe, mas xUnit e NUnit são considerados mais flexíveis para cenários complexos.

Exemplo de teste com xUnit

Vamos testar uma calculadora simples usando xUnit:

using Xunit;

public class Calculator{    public int Add(int a, int b) => a + b;    public int Divide(int a, int b) => b == 0 ? throw new DivideByZeroException() : a / b;}

public class CalculatorTests{    [Fact]    public void Add_ShouldReturnSum_WhenTwoNumbers()    {        // Arrange        var calc = new Calculator();

        // Act        var result = calc.Add(3, 5);

        // Assert        Assert.Equal(8, result);    }

    [Theory]    [InlineData(10, 2, 5)]    [InlineData(9, 3, 3)]    [InlineData(7, 1, 7)]    public void Divide_ShouldReturnQuotient(int a, int b, int expected)    {        var calc = new Calculator();        var result = calc.Divide(a, b);        Assert.Equal(expected, result);    }

    [Fact]    public void Divide_ShouldThrow_WhenDivideByZero()    {        var calc = new Calculator();        Assert.Throws<DivideByZeroException>(() => calc.Divide(5, 0));    }}

O atributo [Fact] denota um teste comum, enquanto [Theory] com [InlineData] permite executar um mesmo teste com diferentes dados de entrada.

Ferramentas para objetos mock

Em testes unitários, muitas vezes é necessário isolar a classe testada de dependências externas (banco de dados, API, sistema de arquivos). Para isso, são usados frameworks de mock:

• Moq — o mais popular, sintaxe simples, boa documentação.
• NSubstitute — mais conciso, com interface fluente.
• FakeItEasy — API amigável para criação rápida de stubs.

Exemplo de uso do Moq

Suponha que temos um serviço que envia e-mail. Queremos testar a lógica sem realmente enviar:

using Moq;using Xunit;

public interface IEmailSender{    void Send(string to, string subject, string body);}

public class NotificationService{    private readonly IEmailSender _sender;    public NotificationService(IEmailSender sender) => _sender = sender;

    public void NotifyUser(string email, string message)    {        if (string.IsNullOrWhiteSpace(email))            throw new ArgumentException("Email is required");        _sender.Send(email, "Notification", message);    }}

public class NotificationServiceTests{    [Fact]    public void NotifyUser_ShouldCallSend_WhenValidEmail()    {        // Arrange        var mockSender = new Mock<IEmailSender>();        var service = new NotificationService(mockSender.Object);

        // Act        service.NotifyUser("test@example.com", "Hello!");

        // Assert        mockSender.Verify(s => s.Send("test@example.com", "Notification", "Hello!"), Times.Once);    }

    [