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

Moq - mockowanie zależności w testach

Podstawowe użycie - tworzenie mocka i konfiguracja zachowania

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(int id);
    Task SaveAsync(Order order);
}

[Fact]
public async Task GetOrder_ExistingId_ReturnsOrder()
{
    // Arrange
    var mockRepository = new Mock<IOrderRepository>();
    mockRepository
        .Setup(r => r.GetByIdAsync(1))
        .ReturnsAsync(new Order { Id = 1, CustomerName = "Jan" });

    var service = new OrderService(mockRepository.Object); // .Object - właściwa implementacja mocka

    // Act
    var order = await service.GetOrderAsync(1);

    // Assert
    Assert.Equal("Jan", order.CustomerName);
}

Zamiast wołać prawdziwe repozytorium (które wymagałoby prawdziwej bazy danych), tworzysz atrapę (mock), która zwraca z góry zdefiniowane dane - dzięki temu test jest szybki, deterministyczny i nie zależy od zewnętrznej infrastruktury.

It.IsAny<T>() - dopasowanie dla dowolnego argumentu

mockRepository
    .Setup(r => r.GetByIdAsync(It.IsAny<int>())) // dopasuje DOWOLNE id
    .ReturnsAsync(new Order { Id = 999, CustomerName = "Test" });

Przydatne, gdy nie chcesz sprawdzać konkretnej wartości argumentu, tylko interesuje Cię ogólne zachowanie mocka.

Verify() - sprawdzenie, że metoda została wywołana

[Fact]
public async Task CreateOrder_ValidOrder_CallsSaveOnce()
{
    var mockRepository = new Mock<IOrderRepository>();
    var service = new OrderService(mockRepository.Object);

    await service.CreateOrderAsync(new Order { CustomerName = "Jan" });

    mockRepository.Verify(r => r.SaveAsync(It.IsAny<Order>()), Times.Once); // dokładnie RAZ
    mockRepository.Verify(r => r.SaveAsync(It.IsAny<Order>()), Times.Never); // sprawdza, że NIE wywołano
}

To pozwala testować zachowanie, nie tylko zwracaną wartość - np. "czy serwis faktycznie próbował zapisać zamówienie", niezależnie od tego, co repozytorium zwróciło.

Mockowanie wyjątków - testowanie obsługi błędów

[Fact]
public async Task GetOrder_RepositoryThrows_PropagatesException()
{
    var mockRepository = new Mock<IOrderRepository>();
    mockRepository
        .Setup(r => r.GetByIdAsync(It.IsAny<int>()))
        .ThrowsAsync(new InvalidOperationException("Błąd bazy danych"));

    var service = new OrderService(mockRepository.Object);

    await Assert.ThrowsAsync<InvalidOperationException>(() => service.GetOrderAsync(1));
}

Mockowanie sekwencji wywołań - różne wartości przy kolejnych wywołaniach

mockRepository
    .SetupSequence(r => r.GetByIdAsync(1))
    .ReturnsAsync(new Order { Status = "Pending" })  // pierwsze wywołanie
    .ReturnsAsync(new Order { Status = "Shipped" });  // drugie wywołanie

Callback - wykonanie dodatkowej logiki przy wywołaniu mocka

var savedOrders = new List<Order>();

mockRepository
    .Setup(r => r.SaveAsync(It.IsAny<Order>()))
    .Callback<Order>(order => savedOrders.Add(order)) // przechwytujesz argument, robisz coś z nim
    .Returns(Task.CompletedTask);

await service.CreateOrderAsync(new Order { CustomerName = "Jan" });

Assert.Single(savedOrders);
Assert.Equal("Jan", savedOrders[0].CustomerName);

Mockowanie zależności przy DI - integracja z tym, co już wiemy

To jest naturalne rozwinięcie constructor injection, o którym mówiliśmy wcześniej - mock to po prostu alternatywna implementacja interfejsu, wstrzykiwana przez konstruktor tak samo, jak w prawdziwej aplikacji:

public class OrderService : IOrderService
{
    private readonly IOrderRepository _repository;
    private readonly ILogger<OrderService> _logger;

    public OrderService(IOrderRepository repository, ILogger<OrderService> logger)
    {
        _repository = repository;
        _logger = logger;
    }
}
[Fact]
public async Task Test()
{
    var mockRepository = new Mock<IOrderRepository>();
    var mockLogger = new Mock<ILogger<OrderService>>(); // MOŻNA mockować nawet ILogger

    var service = new OrderService(mockRepository.Object, mockLogger.Object); // DOKŁADNIE ten sam konstruktor
}

To jest właśnie dlaczego DI przez konstruktor (a nie Service Locator czy Ambient Context) jest tak wartościowe dla testowalności - każda zależność jest jawnie widoczna i łatwo podmienna na mocka, bez żadnych sztuczek.

Podsumowanie kluczowych metod Moq

Metoda Cel
Setup() Konfiguracja zachowania mocka dla konkretnego wywołania
Returns()/ReturnsAsync() Zwracana wartość (synchroniczna/asynchroniczna)
ThrowsAsync() Symulacja rzucenia wyjątku
Verify() Sprawdzenie, że metoda została wywołana (z jaką częstotliwością)
It.IsAny<T>() Dopasowanie dla dowolnego argumentu danego typu
Callback() Wykonanie dodatkowej logiki przy wywołaniu mocka
SetupSequence() Różne wartości przy kolejnych wywołaniach tej samej metody
Postaw mi kawę