tdd

TDD — Test-Driven Development para .NET Core

Flujo TDD estricto

RED  ->  GREEN  ->  REFACTOR

Estructura de archivos de prueba

Organiza las pruebas reflejando la estructura del codigo fuente.

• Una carpeta por cada clase a testear
• Un archivo .cs por cada metodo de negocio
• Todos los escenarios de ese metodo como metodos [Fact] dentro del mismo archivo

tests/{Service}.UnitTests/
├── Application/
│   └── Orders/
│       ├── CreateOrderHandlerTests/
│       │   ├── HandleAsyncTests.cs          ← metodo Handle
│       │   └── ValidateAsyncTests.cs        ← metodo Validate (si existe)
│       └── CancelOrderHandlerTests/
│           └── HandleAsyncTests.cs
├── Domain/
│   └── Orders/
│       └── OrderTests/
│           ├── AddLineItemTests.cs           ← metodo AddLineItem
│           └── SubmitTests.cs               ← metodo Submit

Reglas de organizacion

Regla	Ejemplo
Carpeta por clase	CreateOrderHandlerTests/ para CreateOrderHandler
Un .cs por metodo	HandleAsyncTests.cs para el metodo HandleAsync
N escenarios dentro	Todos los [Fact] del metodo HandleAsync en HandleAsyncTests.cs
Clase nombrada {Metodo}Tests	public class HandleAsyncTests

Nombramiento Gherkin para escenarios

Dentro de la clase de test, cada metodo [Fact] sigue el patron:

Should_{ResultadoEsperado}_When_{Condicion}

El nombre del metodo bajo prueba ya esta en la clase y el archivo. No se repite en el nombre del escenario.

Prefijos segun tipo de escenario

Prefijo	Uso
Should_	Camino feliz: resultado esperado
Should_ReturnError_When_	Error de validacion o dominio
Should_Throw_When_	Excepcion esperada
Should_Rollback_When_	Compensacion o saga

Ejemplo: archivo HandleAsyncTests.cs

public class HandleAsyncTests
{
    private readonly Mock<IOrderRepository> _repoMock = new();
    private readonly Mock<IUnitOfWork> _uowMock = new();
    private readonly CreateOrderHandler _sut;

    public HandleAsyncTests()
    {
        _sut = new CreateOrderHandler(_repoMock.Object, _uowMock.Object);
    }

    [Fact]
    public async Task Should_CreateOrder_When_CommandIsValid()
    {
        // Arrange --------------------------------------------------------
        var command = new CreateOrderCommand(
            ProductId.New(),
            Quantity.From(2),
            Money.From(100, "USD"));

        Order? captured = null;
        _repoMock
            .Setup(r => r.AddAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()))
            .Callback<Order, CancellationToken>((o, _) => captured = o);
        _uowMock
            .Setup(u => u.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1);

        // Act ------------------------------------------------------------
        var result = await _sut.Handle(command, CancellationToken.None);

        // Assert ----------------------------------------------------------
        result.IsSuccess.Should().BeTrue();
        result.Value.Id.Should().NotBeEmpty();
        captured.Should().NotBeNull();
        captured!.Lines.Should().HaveCount(1);
        _repoMock.Verify(r => r.AddAsync(It.IsAny<Order>(), It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task Should_ReturnValidationError_When_QuantityIsNegative()
    {
        // Arrange --------------------------------------------------------
        var command = new CreateOrderCommand(
            ProductId.New(),
            Quantity.From(-5),
            Money.From(100, "USD"));

        // Act ------------------------------------------------------------
        var result = await _sut.Handle(command, CancellationToken.None);

        // Assert ----------------------------------------------------------
        result.IsFailed.Should().BeTrue();
        result.Errors.Should().Contain(e => e.Code == "Order.Quantity.Negative");
    }

    [Fact]
    public async Task Should_ReturnError_When_ProductNotFound()
    {
        // Arrange --------------------------------------------------------
        var command = new CreateOrderCommand(
            ProductId.New(),
            Quantity.From(1),
            Money.From(100, "USD"));

        _repoMock
            .Setup(r => r.GetProductAsync(command.ProductId, It.IsAny<CancellationToken>()))
            .ReturnsAsync((Product?)null);

        // Act ------------------------------------------------------------
        var result = await _sut.Handle(command, CancellationToken.None);

        // Assert ----------------------------------------------------------
        result.IsFailed.Should().BeTrue();
        result.Errors.Should().Contain(e => e.Code == "Product.NotFound");
    }

    [Fact]
    public async Task Should_RollbackInventory_When_PaymentFails()
    {
        // Arrange --------------------------------------------------------
        var command = new CreateOrderCommand(
            ProductId.New(),
            Quantity.From(2),
            Money.From(100, "USD"));

        _repoMock
            .Setup(r => r.GetProductAsync(command.ProductId, It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Product { Id = command.ProductId, Stock = 10 });
        _uowMock
            .SetupSequence(u => u.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1)   // reserva exitosa
            .ThrowsAsync(new PaymentFailedException());  // pago falla

        // Act ------------------------------------------------------------
        Func<Task> act = () => _sut.Handle(command, CancellationToken.None);

        // Assert ----------------------------------------------------------
        await act.Should().ThrowAsync<PaymentFailedException>();
        _repoMock.Verify(r => r.ReleaseStockAsync(command.ProductId, command.Quantity, It.IsAny<CancellationToken>()), Times.Once);
    }
}