Testes
Com agentes de IA escrevendo código, teste deixou de ser opcional: é a única forma de saber se o que foi gerado faz o que deveria. Escrevi sobre isso em TDD Is No Longer Optional in the World of AI Agents.
A pirâmide, na prática
- Unitários (muitos, milissegundos): domínio e casos de uso, com as dependências substituídas.
- Integração (alguns, segundos): API de verdade, banco de verdade em container. Ver Testes de integração.
- Ponta a ponta (poucos, minutos): os fluxos que dão dinheiro, no ambiente mais parecido com produção.
Em backend, os testes de integração da API são os que mais me dão confiança por linha escrita. Se o tempo é curto, comece por eles.
Stack
| Para | Uso | Observação |
|---|---|---|
| Framework | xUnit | o mais usado em .NET; NUnit e MSTest resolvem igual |
| Dublês | NSubstitute | sintaxe limpa; o Moq continua muito presente nos projetos legados |
| Asserções | Shouldly ou asserts do xUnit | o FluentAssertions passou a ter licença comercial na versão 8 (2025) |
| Integração | WebApplicationFactory + Testcontainers |
banco real, descartável |
| Dados de teste | Bogus | quando o volume ajuda |
| Cobertura | Coverlet + ReportGenerator | o coletor do Coverlet já vem no template do xUnit |
Teste de domínio: sem mock nenhum
O agregado não depende de nada, então o teste é só C#:
public class OrderTests
{
[Fact]
public void Approve_PedidoPendente_MudaParaAprovado()
{
var order = Order.Create("cliente-1", [OrderItem.Create("sku-1", 10m, 2)]);
order.Approve();
Assert.Equal(OrderStatus.Approved, order.Status);
}
[Fact]
public void Approve_PedidoJaAprovado_LancaDomainException()
{
var order = Order.Create("cliente-1", [OrderItem.Create("sku-1", 10m, 2)]);
order.Approve();
Assert.Throws<DomainException>(() => order.Approve());
}
[Theory]
[InlineData("")]
[InlineData(" ")]
public void Create_SemCliente_LancaDomainException(string customerId) =>
Assert.Throws<DomainException>(() => Order.Create(customerId, [OrderItem.Create("sku-1", 10m, 1)]));
}
Teste de caso de uso: dublês nas bordas
public class CreateOrderUseCaseTests
{
private readonly IOrderRepository _repository = Substitute.For<IOrderRepository>();
private readonly IUnitOfWork _unitOfWork = Substitute.For<IUnitOfWork>();
private readonly IEventPublisher _publisher = Substitute.For<IEventPublisher>();
private CreateOrderUseCase CriarSut() =>
new(_repository, _unitOfWork, new OrderDomainService(), new OrderFactory(), _publisher);
[Fact]
public async Task ExecuteAsync_ClienteNoLimite_NaoSalvaNemPublica()
{
// O OrderDomainService aceita até 3 pedidos pendentes por cliente
_repository.GetByCustomerIdAsync("cliente-1", Arg.Any<CancellationToken>())
.Returns(PedidosPendentes("cliente-1", quantidade: 3));
var resultado = await CriarSut().ExecuteAsync(NovoPedido("cliente-1"));
Assert.True(resultado.IsFailed);
await _unitOfWork.DidNotReceive().CommitAsync(Arg.Any<CancellationToken>());
await _publisher.DidNotReceive().PublishAsync(Arg.Any<OrderCreatedIntegrationEvent>(), Arg.Any<CancellationToken>());
}
[Fact]
public async Task ExecuteAsync_AbaixoDoLimite_SalvaUmaVezEPublica()
{
_repository.GetByCustomerIdAsync("cliente-1", Arg.Any<CancellationToken>())
.Returns(PedidosPendentes("cliente-1", quantidade: 2));
var resultado = await CriarSut().ExecuteAsync(NovoPedido("cliente-1"));
Assert.True(resultado.IsSuccess);
Assert.Equal(20m, resultado.Value.Total);
await _unitOfWork.Received(1).CommitAsync(Arg.Any<CancellationToken>());
}
private static IEnumerable<Order> PedidosPendentes(string clienteId, int quantidade) =>
Enumerable.Range(0, quantidade)
.Select(_ => Order.Create(clienteId, [OrderItem.Create("sku-1", 10m, 1)]))
.ToList();
private static CreateOrderInput NovoPedido(string clienteId) =>
new(clienteId, [new OrderItemInput("sku-1", 10m, 2)]);
}
Mocke só o que sai do processo (banco, fila, HTTP, relógio). Mockar classes do próprio domínio deixa o teste acoplado à implementação: qualquer refatoração quebra tudo sem que o comportamento tenha mudado.
Boas práticas que mais cobro em code review
- Nome que conta a história:
Metodo_Cenario_ResultadoEsperado. - Arrange, Act, Assert separados por linha em branco. Um Act por teste.
- Teste determinístico: nada de
DateTime.Nowdireto no código; injeteTimeProvider(nativo desde o .NET 8) e useFakeTimeProviderno teste. - Teste independente: nenhum teste depende da ordem ou do estado deixado por outro.
- Teste o comportamento, não a implementação: verificar que
_repository.Received(1).AddAsync(...)foi chamado é menos útil do que verificar o resultado.
TDD
Escreva o teste que falha, faça passar do jeito mais simples, refatore. O ganho não é ter teste, é o design: código difícil de testar é código acoplado, e o TDD mostra isso antes de existir.
Com agentes de IA, o ciclo fica ainda melhor: você escreve (ou revisa) os testes que definem o comportamento e deixa o agente implementar até ficarem verdes.
Cobertura
Cobertura mede o que foi executado, não o que foi verificado. Um teste sem Assert dá 100% de cobertura e zero de confiança. Uso a cobertura para achar código de domínio sem teste, não como meta. Se o time exige número, 80% no Domain e na Application é razoável; exigir 80% em controllers e configuração gera teste inútil.
dotnet test --collect:"XPlat Code Coverage"
O que perguntam em entrevista
- Diferença entre teste unitário e de integração, e quando usar cada um.
- Mock, stub e fake: qual a diferença.
- Como testar um código que usa
DateTime.Now. - O que é TDD e quando você aplica.
- Cobertura de 100% garante qualidade?