Comprehensive Guide to C# Testing with xUnit and ASP.NET

Enhance Your ASP.NET Applications with Robust Unit Tests Using C# and xUnit

Guia Completo para Testes em C# com xUnit e ASP.NET
Aprimore suas Aplicações ASP.NET com Testes de Unidade Robustos Usando C# e xUnit

Para começarmos a jornada de testes em C# com xUnit, é fundamental configurar o ambiente corretamente. Primeiramente, crie um projeto ASP.NET (Web API é um bom exemplo) no Visual Studio ou no seu IDE preferido. Em seguida, adicione um novo projeto do tipo “Projeto de Teste xUnit (.NET)”. No projeto de teste, instale os seguintes pacotes NuGet: `xunit`, `xunit.runner.visualstudio` e `Microsoft.NET.Test.Sdk`. Certifique-se de que a versão do .NET SDK instalada no seu ambiente é compatível com o seu projeto ASP.NET. Para vincular o projeto de teste ao projeto principal, adicione uma referência do projeto de teste ao projeto ASP.NET. Após a instalação dos pacotes, verifique se o test runner (Visual Studio Test Explorer ou dotnet test na linha de comando) reconhece os testes.

Vamos agora escrever o nosso primeiro teste unitário com xUnit. Suponha que temos uma classe `Calculadora` com um método `Adicionar`:

“`csharp
public class Calculadora
{
public int Adicionar(int a, int b)
{
return a + b;
}
}
“`

Para testar este método, criamos uma classe de teste `CalculadoraTests`:

“`csharp
using Xunit;

public class CalculadoraTests
{
[Fact]
public void Adicionar_DeveRetornarASoma_QuandoValoresForemInformados()
{
// Arrange
var calculadora = new Calculadora();
int a = 5;
int b = 3;
int resultadoEsperado = 8;

// Act
int resultadoAtual = calculadora.Adicionar(a, b);

// Assert
Assert.Equal(resultadoEsperado, resultadoAtual);
}
}
“`

Observe o padrão Arrange, Act, Assert (AAA). `[Fact]` indica que este é um método de teste. `Assert.Equal` verifica se o valor atual é igual ao valor esperado.

xUnit oferece uma gama rica de atributos e asserções para diferentes cenários de teste. O atributo `[Fact]` já foi apresentado, ideal para testes simples. `[Theory]` permite executar o mesmo teste com diferentes conjuntos de dados. `[InlineData]` fornece dados diretamente no atributo: `[Theory][InlineData(2, 3, 5)][InlineData(4, 6, 10)]`. Para dados mais complexos, `[MemberData]` e `[ClassData]` referenciam propriedades ou classes que retornam os dados. `[Trait]` permite adicionar metadados aos testes, facilitando a categorização e filtragem. As asserções incluem `Assert.NotEqual`, `Assert.True`, `Assert.False`, `Assert.Null`, `Assert.NotNull`, `Assert.Empty`, `Assert.NotEmpty`. `Assert.Throws` é crucial para verificar se um método lança a exceção esperada. Por exemplo, `Assert.Throws(() => calculadora.Dividir(10, 0));`.

Testar código assíncrono exige atenção especial. Utilize os modificadores `async` e `await` em seus métodos de teste. Para testar um método assíncrono que retorna `Task`, use `await` para obter o resultado: `var resultado = await metodoAssincrono();`. Para verificar exceções em código assíncrono, use `Assert.ThrowsAsync`. Por exemplo:

“`csharp
[Fact]
public async Task MetodoAssincrono_DeveLancarExcecao_QuandoCondicaoNaoSatisfazer()
{
await Assert.ThrowsAsync(async () => await _servico.MetodoAssincrono(argumentoInvalido));
}
“`

Lembre-se de configurar timeouts apropriados para evitar testes que se estendem indefinidamente. CancellationToken pode ser usado para cancelar operações assíncronas demoradas.

O mocking é fundamental para isolar a unidade que está sendo testada, substituindo dependências externas por objetos controlados. Frameworks como Moq e NSubstitute facilitam a criação e configuração de mocks. Para criar um mock com Moq, use `var mockDependencia = new Mock();`. Você pode então configurar o comportamento do mock: `mockDependencia.Setup(x => x.Metodo(It.IsAny())).Returns(true);`. Injete o mock na classe sob teste através do construtor ou propriedade. Para verificar se um método do mock foi chamado, use `mockDependencia.Verify(x => x.Metodo(It.Is(i => i > 0)), Times.Once);`. O `Times.Once` garante que o método foi chamado exatamente uma vez.

Para testar controllers ASP.NET, é essencial simular o ambiente HTTP. Utilize `Mock` para mockar o contexto HTTP. Crie mocks para as dependências do controller, como serviços e repositórios. Por exemplo: `var mockServico = new Mock();`. Configure o comportamento esperado dos mocks: `mockServico.Setup(x => x.ObterDados()).Returns(new List { “dado1”, “dado2” });`. Ao testar métodos GET, verifique o status code retornado (Assert.IsType) e o conteúdo da resposta. Para métodos POST, PUT e DELETE, verifique se as operações foram realizadas corretamente (e.g., se um registro foi criado ou atualizado) e se os status codes apropriados foram retornados (e.g., 201 Created, 204 No Content). Teste também a validação do modelo, verificando se erros de validação retornam o status code 400 Bad Request.

Testes orientados a dados, ou Theories, são ideais para validar o comportamento de um método com múltiplos conjuntos de entrada. Utilize o atributo `[Theory]` em conjunto com `[InlineData]` para fornecer valores diretamente no código:

“`csharp
[Theory]
[InlineData(10, 2, 5)]
[InlineData(15, 3, 5)]
[InlineData(20, 4, 5)]
public void Dividir_DeveRetornarResultadoCorreto(int dividendo, int divisor, int resultadoEsperado)
{
var calculadora = new Calculadora();
Assert.Equal(resultadoEsperado, calculadora.Dividir(dividendo, divisor));
}
“`

Para conjuntos de dados mais complexos, utilize `[MemberData]` ou `[ClassData]` para obter os dados de um método ou classe:

“`csharp
public static IEnumerable DadosDivisao()
{
yield return new object[] { 10, 2, 5 };
yield return new object[] { 15, 3, 5 };
yield return new object[] { 20, 4, 5 };
}

[Theory]
[MemberData(nameof(DadosDivisao))]
public void Dividir_DeveRetornarResultadoCorreto_ComMemberData(int dividendo, int divisor, int resultadoEsperado)
{
var calculadora = new Calculadora();
Assert.Equal(resultadoEsperado, calculadora.Dividir(dividendo, divisor));
}
“`

Testes de integração validam a interação entre diferentes partes da aplicação, como controllers, serviços, repositórios e bancos de dados. Ao contrário dos testes de unidade, os testes de integração envolvem componentes reais e suas dependências. Configure um ambiente de teste isolado, utilizando um banco de dados de teste (in-memory ou uma cópia do banco de dados de produção). Utilize o `WebApplicationFactory` para criar um servidor de teste para sua aplicação ASP.NET. Injeção de dependência (DI) é crucial aqui. Use o `ConfigureServices` método no `WebApplicationFactory` para substituir as dependências reais por versões mockadas ou stubs. Escreva testes que simulem fluxos de usuários reais, verificando se as operações no banco de dados, chamadas a APIs externas e filas de mensagens funcionam como esperado.

A escrita de testes legíveis e mantíveis é crucial para o sucesso a longo prazo de um projeto. Nomes de testes devem ser descritivos e indicar claramente o que está sendo testado (ex: `Metodo_QuandoCondicao_EntaoResultado`). Utilize o padrão AAA (Arrange, Act, Assert) de forma consistente para estruturar seus testes. Evite duplicação de código criando métodos auxiliares para tarefas repetitivas. Mantenha os testes independentes uns dos outros para evitar efeitos colaterais e garantir a confiabilidade dos resultados. Pratique Test-Driven Development (TDD), escrevendo os testes antes da implementação do código, para garantir que o código atenda aos requisitos desde o início. Refatore seus testes regularmente para remover código duplicado, melhorar a legibilidade e manter