C# / .NET Kompendium PLEN
.NET / C# / Testy

xUnit - podstawy testowania w .NET

Struktura podstawowego testu

public class OrderValidatorTests
{
    [Fact] // test bez parametrów, sprawdza JEDEN konkretny scenariusz
    public void Validate_EmptyOrder_ReturnsFalse()
    {
        // Arrange
        var validator = new OrderValidator();
        var order = new Order { Items = new List<OrderItem>() };

        // Act
        var result = validator.Validate(order);

        // Assert
        Assert.False(result);
    }
}

Konwencja AAA (Arrange-Act-Assert) - trzy sekcje: przygotowanie danych, wykonanie akcji, sprawdzenie wyniku. To jest standard w testach jednostkowych, ułatwiający czytelność - patrząc na test od razu widzisz, co jest przygotowaniem, a co sprawdzeniem.

[Theory] - jeden test, wiele zestawów danych

[Theory]
[InlineData(0, false)]
[InlineData(-5, false)]
[InlineData(100, true)]
public void Validate_TotalAmount_ReturnsExpectedResult(decimal amount, bool expected)
{
    var validator = new OrderValidator();
    var order = new Order { TotalAmount = amount };

    var result = validator.Validate(order);

    Assert.Equal(expected, result);
}

[Theory] + [InlineData] pozwala uniknąć duplikacji - jeden test wykonuje się wielokrotnie z różnymi zestawami danych, zamiast pisać 3 osobne metody [Fact] różniące się tylko wartościami.

[MemberData] - dla bardziej złożonych danych testowych, niereprezentowalnych jako literały w atrybucie:

public static IEnumerable<object[]> OrderTestCases()
{
    yield return new object[] { new Order { Items = new List<OrderItem>() }, false };
    yield return new object[] { new Order { Items = new List<OrderItem> { new() } }, true };
}

[Theory]
[MemberData(nameof(OrderTestCases))]
public void Validate_VariousOrders_ReturnsExpectedResult(Order order, bool expected)
{
    var result = new OrderValidator().Validate(order);
    Assert.Equal(expected, result);
}

IClassFixture<T> - współdzielony kontekst dla wielu testów w klasie

To rozwiązuje problem, gdy przygotowanie danych testowych jest kosztowne (np. utworzenie połączenia do bazy testowej) i nie chcesz go powtarzać przed każdym testem:

public class DatabaseFixture : IDisposable
{
    public AppDbContext Context { get; }

    public DatabaseFixture()
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseInMemoryDatabase("TestDb") // baza w pamięci, bez realnego SQL Server
            .Options;

        Context = new AppDbContext(options);
        Context.Orders.Add(new Order { Id = 1, CustomerName = "Test" });
        Context.SaveChanges();
    }

    public void Dispose() => Context.Dispose();
}

public class OrderServiceTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _fixture;

    public OrderServiceTests(DatabaseFixture fixture) // xUnit WSTRZYKUJE fixture do konstruktora
    {
        _fixture = fixture;
    }

    [Fact]
    public async Task GetOrder_ExistingId_ReturnsOrder()
    {
        var service = new OrderService(_fixture.Context);
        var order = await service.GetOrderAsync(1);
        Assert.NotNull(order);
    }
}

Kluczowa cecha IClassFixture: fixture jest tworzony jeden raz dla wszystkich testów w danej klasie (nie przed każdym testem osobno) - konstruktor DatabaseFixture wykonuje się raz, Dispose() wywołuje się po zakończeniu wszystkich testów w klasie.

Kontrast z konstruktorem klasy testowej - xUnit tworzy nową instancję klasy testowej dla KAŻDEGO testu (żeby testy były izolowane), ale IClassFixture przełamuje to, dając jedną współdzieloną instancję fixture między wszystkimi testami tej klasy.

ICollectionFixture<T> - współdzielenie między wieloma klasami testowymi

[CollectionDefinition("Database collection")]
public class DatabaseCollection : ICollectionFixture<DatabaseFixture> { }

[Collection("Database collection")]
public class OrderServiceTests
{
    public OrderServiceTests(DatabaseFixture fixture) { }
}

[Collection("Database collection")] // TA SAMA fixture, współdzielona z OrderServiceTests
public class CustomerServiceTests
{
    public CustomerServiceTests(DatabaseFixture fixture) { }
}

Podsumowanie kluczowych atrybutów

Atrybut/Interfejs Cel
[Fact] Test pojedynczego, konkretnego scenariusza
[Theory] + [InlineData] Test z wielokrotnymi, prostymi zestawami danych
[Theory] + [MemberData] Test z bardziej złożonymi danymi testowymi
IClassFixture<T> Współdzielony kontekst dla wszystkich testów w JEDNEJ klasie
ICollectionFixture<T> Współdzielony kontekst między WIELOMA klasami testowymi
Postaw mi kawę