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

Testy integracyjne w ASP.NET Core

Różnica względem testów jednostkowych

Testy jednostkowe (z Moq) testują jedną klasę w izolacji, mockując wszystkie zależności. Testy integracyjne sprawdzają, jak wiele komponentów współpracuje - np. cały request HTTP przez middleware, kontroler, serwis, aż do (prawdziwej albo testowej) bazy danych.

WebApplicationFactory<T> - hostowanie aplikacji w testach

public class OrdersControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrdersControllerTests(WebApplicationFactory<Program> factory)
    {
        _client = factory.CreateClient(); // uruchamia CAŁĄ aplikację "in-memory", bez realnego serwera
    }

    [Fact]
    public async Task GetOrder_ExistingId_ReturnsOkWithOrder()
    {
        var response = await _client.GetAsync("/api/orders/1");

        response.EnsureSuccessStatusCode();
        var order = await response.Content.ReadFromJsonAsync<OrderDto>();
        Assert.NotNull(order);
    }
}

WebApplicationFactory<Program> uruchamia Twoją całą aplikację ASP.NET Core (Program.cs, cały pipeline middleware, DI, routing) w pamięci procesu testowego - _client wysyła prawdziwe requesty HTTP, przechodzące przez cały realny stack aplikacji, ale bez potrzeby uruchamiania osobnego serwera/portu.

Podmiana zależności na potrzeby testów - WithWebHostBuilder

public class OrdersControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrdersControllerTests(WebApplicationFactory<Program> factory)
    {
        var customFactory = factory.WithWebHostBuilder(builder =>
        {
            builder.ConfigureServices(services =>
            {
                // Usuwamy prawdziwy DbContext (skonfigurowany w Program.cs)
                var descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextOptions<AppDbContext>));
                if (descriptor != null) services.Remove(descriptor);

                // Podmieniamy na bazę w pamięci (InMemory) na czas testów
                services.AddDbContext<AppDbContext>(options => options.UseInMemoryDatabase("TestDb"));
            });
        });

        _client = customFactory.CreateClient();
    }
}

To pozwala zachować realną konfigurację middleware/routingu/DI, ale podmienić konkretne, "niewygodne" w testach zależności (np. prawdziwą bazę SQL Server na bazę w pamięci) - dokładnie ta sama idea co mockowanie w Moq, tylko na wyższym poziomie (cała aplikacja, nie pojedyncza klasa).

Testcontainers - testy integracyjne z PRAWDZIWĄ bazą danych (w kontenerze Docker)

To jest bardziej rygorystyczne podejście niż InMemory database - baza InMemory z EF Core nie zachowuje się identycznie jak prawdziwy SQL Server (np. inne zachowanie przy niektórych zapytaniach, ograniczenia transakcji) - Testcontainers rozwiązuje to, uruchamiając prawdziwą bazę danych w kontenerze Docker, tylko na czas testów.

public class DatabaseFixture : IAsyncLifetime
{
    private readonly MsSqlContainer _sqlContainer = new MsSqlBuilder().Build();
    public string ConnectionString => _sqlContainer.GetConnectionString();

    public async Task InitializeAsync()
    {
        await _sqlContainer.StartAsync(); // uruchamia PRAWDZIWY SQL Server w kontenerze Docker
    }

    public async Task DisposeAsync()
    {
        await _sqlContainer.DisposeAsync(); // zatrzymuje i usuwa kontener po testach
    }
}

public class OrderRepositoryIntegrationTests : IClassFixture<DatabaseFixture>
{
    private readonly AppDbContext _context;

    public OrderRepositoryIntegrationTests(DatabaseFixture fixture)
    {
        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer(fixture.ConnectionString) // PRAWDZIWE zapytania SQL, nie symulacja InMemory
            .Options;
        _context = new AppDbContext(options);
        _context.Database.Migrate(); // stosuje migracje do "świeżej" bazy w kontenerze
    }

    [Fact]
    public async Task SaveOrder_WithItems_PersistsCorrectly()
    {
        var repository = new OrderRepository(_context);
        var order = new Order { CustomerName = "Jan", Items = { new OrderItem { ProductId = 1 } } };

        await repository.AddAsync(order);
        await _context.SaveChangesAsync();

        var saved = await _context.Orders.Include(o => o.Items).FirstAsync(o => o.Id == order.Id);
        Assert.Single(saved.Items); // sprawdza RZECZYWISTE zachowanie SQL Server, nie symulację
    }
}

Zaleta: testy sprawdzają rzeczywiste zachowanie bazy danych (constraints, typy danych, specyficzne zachowania SQL Server), nie tylko przybliżoną symulację InMemory provider'a.

Koszt: wolniejsze (start kontenera Docker trwa kilka sekund), wymaga zainstalowanego Dockera na maszynie CI/CD i lokalnie u developerów.

Piramida testów - gdzie to wszystko się układa

        /\
       /  \    E2E (end-to-end) - najmniej, najwolniejsze, testują CAŁY system
      /----\
     /      \  Testy integracyjne (WebApplicationFactory, Testcontainers) - średnio
    /--------\
   /          \ Testy jednostkowe (xUnit + Moq) - najwięcej, najszybsze, testują izolowane klasy
  /------------\

Praktyczna reguła: większość testów powinna być jednostkowa (szybka, izolowana logika biznesowa z Moq), mniej integracyjnych (sprawdzających współpracę warstw - kontroler + DI + baza), a najmniej E2E (testujących cały system przez UI, najwolniejsze i najbardziej kruche).

Podsumowanie - kiedy który typ testu

Typ testu Co sprawdza Narzędzia Szybkość
Jednostkowy Jedna klasa w izolacji xUnit + Moq Bardzo szybkie (ms)
Integracyjny (InMemory) Współpraca warstw, przybliżone zachowanie bazy WebApplicationFactory + EF InMemory Szybkie (dziesiątki ms)
Integracyjny (Testcontainers) Współpraca warstw, RZECZYWISTE zachowanie bazy WebApplicationFactory + Testcontainers Wolniejsze (sekundy, start kontenera)
E2E Cały system, przez prawdziwe UI/API Selenium, Playwright Najwolniejsze
Postaw mi kawę