Zrozumienie Asercji w xUnit: Kluczowe Metody i Ich Zastosowanie

Assert.Fail

Assert.Fail nie jest bezpośrednio dostępna w xUnit jako taka, ponieważ xUnit zachęca do używania asercji typu “Assert.True(false, message);” aby wymusić niepowodzenie testu. Tego rodzaju asercja jest używana, gdy chcemy bezpośrednio zgłosić błąd w teście.

Prosty przykład:

[Fact]
public void TestShouldFail()
{
    // Act & Assert
    // Wymuszenie niepowodzenia testu
    Assert.True(false, "Test failed intentionally.");
}

Przykład z mockowaniem:

Podobny do powyższego, mockowanie nie jest tu konieczne, gdyż asercja nie zależy od zewnętrznych zależności.

Assert.False

Assert.False sprawdza, czy podane wyrażenie boolowskie jest fałszywe. Jest to używane do weryfikacji, że określone warunki nie są spełnione.

Prosty przykład:

[Fact]
// Definiuje metodę jako test jednostkowy
public void UserIsMinor_ReturnsFalse_WhenAgeIsOver18()
{
    // Arrange
    // Tworzenie nowego użytkownika z wiekiem 20 lat
    User user = new User { Age = 20 };


    // Act
    // Sprawdzenie, czy wiek użytkownika jest mniejszy lub równy 18 lat
    bool isMinor = user.Age <= 18;

    // Assert
    // Potwierdzenie, że użytkownik nie jest nieletni
    Assert.False(isMinor);
}

Assert.InRange

Assert.InRange sprawdza, czy dana wartość liczbowа mieści się w określonym zakresie.

Prosty przykład:

[Fact]
public void ValueIsWithinRange()
{
    // Arrange
    // Definiowanie liczby
    int number = 5;

    // Act & Assert
    // Sprawdzenie, czy liczba znajduje się w zakresie od 1 do 10
    Assert.InRange(number, 1, 10);
}

Przykład z mockowaniem:

[Fact]
public void TemperatureIsWithinSafeLimits()
{
    // Arrange
    var mockThermostat = new Mock<IThermostat>();

    // Konfiguracja mocka zwracającego aktualną temperaturę
    mockThermostat.Setup(t => t.CurrentTemperature).Returns(72);

    // Act
    // Pobranie temperatury
    var temp = mockThermostat.Object.CurrentTemperature;

    // Assert
    // Sprawdzenie, czy temperatura jest w bezpiecznych granicach
    Assert.InRange(temp, 60, 75);
}

Assert.IsAssignableFrom

Assert.IsAssignableFrom<T> sprawdza, czy dany obiekt może być przypisany do zmiennej określonego typu T. Jest to przydatne, kiedy chcemy upewnić się, że obiekt implementuje określony interfejs lub dziedziczy z danej klasy.

Prosty przykład:

[Fact]
public void ObjectIsAssignableFromType()
{
    // Arrange
    // Definicja obiektu jako ciągu znaków
    object someObject = "To jest ciąg znaków";

    // Act & Assert
    // Sprawdzenie, czy obiekt można przypisać do typu string
    Assert.IsAssignableFrom<string>(someObject);
}

Przykład z mockowaniem:

[Fact]
public void ServiceIsAssignableFromBaseType()
{
    // Arrange
    // Tworzenie mocka dla MyService
    var mockService = new Mock<MyService>();

    // Act & Assert
    // Sprawdzenie, czy mock MyService można przypisać do typu ServiceBase
    Assert.IsAssignableFrom<ServiceBase>(mockService.Object);
}

Assert.IsNotAssignableFrom

Assert.IsNotAssignableFrom<T> weryfikuje, że dany obiekt nie może być przypisany do zmiennej określonego typu T.

Prosty przykład:

[Fact]
public void ObjectIsNotAssignableFromType()
{
    // Arrange
    // Definicja obiektu jako listy liczb całkowitych
    object someObject = new List<int>();

    // Act & Assert
    // Sprawdzenie, czy obiekt nie może być przypisany do typu string
    Assert.IsNotAssignableFrom<string>(someObject);
}

Przykład z mockowaniem:

[Fact]
public void ServiceIsNotAssignableFromUnrelatedType()
{
    // Arrange
    // Tworzenie mocka dla MyService
    var mockService = new Mock<MyService>();

    // Act & Assert
    // Sprawdzenie, czy mock MyService nie może być przypisany do interfejsu IDisposable
    Assert.IsNotAssignableFrom<IDisposable>(mockService.Object);
}

Assert.IsNotType

Assert.IsNotType<T> sprawdza, czy obiekt nie jest dokładnie danego typu T. Jest to użyteczne do weryfikacji, że obiekt nie jest instancją określonej klasy.

Prosty przykład:

[Fact]
public void ObjectIsNotOfType()
{
    // Arrange
    // Definicja obiektu jako listy liczb całkowitych
    object someObject = new List<int>();

    // Act & Assert
    // Sprawdzenie, czy obiekt nie jest typu string
    Assert.IsNotType<string>(someObject);
}

Przykład z mockowaniem:

[Fact]
public void ServiceIsNotOfTypeUnrelatedClass()
{
    // Arrange
    // Tworzenie mocka dla MyService
    var mockService = new Mock<MyService>();

    // Act & Assert
    // Sprawdzenie, czy mock MyService nie jest typu DateTime
    Assert.IsNotType<DateTime>(mockService.Object);
}

Assert.IsType

Assert.IsType<T> sprawdza, czy dany obiekt jest dokładnie typu T. Jest to użyteczne, gdy chcesz upewnić się, że metoda zwraca obiekt oczekiwanego typu.

Prosty przykład:

[Fact]
public void ObjectIsOfType()
{
    // Arrange
    // Przykładowy obiekt typu string
    object result = "Siema z rana gra gitara!";

    // Act & Assert
    // Sprawdzenie, czy wynik jest typu string
    Assert.IsType<string>(result);
}

Przykład z mockowaniem:

[Fact]
public void ServiceReturnsCorrectType()
{
    // Arrange
    // Tworzenie mocka usługi
    var mockService = new Mock<IMyService>();

    // Konfiguracja usługi, aby zwracała dane typu string
    mockService.Setup(s => s.GetData()).Returns("Przykładowe dane");

    // Act
    // Wywołanie metody, aby pobrać dane
    var result = mockService.Object.GetData();

    // Assert
    // Sprawdzenie, czy zwrócone dane są typu string
    Assert.IsType<string>(result);
}

Assert.Matches

Assert.Matches weryfikuje, czy określony ciąg znaków pasuje do wzorca wyrażenia regularnego.

Prosty przykład:

[Fact]
public void StringMatchesPattern()
{
    // Arrange
    // Definicja ciągu wejściowego
    string input = "Hello123";

    // Act & Assert
    // Sprawdzenie, czy ciąg znaków pasuje do wzorca (jedno lub więcej znaków alfanumerycznych)
    Assert.Matches(@"^\w+$", input);
}

Przykład z mockowaniem:

[Fact]
public void UsernameMatchesExpectedPattern()
{
    // Arrange
    var mockUser = new Mock<IUser>();
    
    // Konfiguracja mocka zwracającego nazwę użytkownika
    mockUser.Setup(u => u.Username).Returns("User_123");

    // Act
    // Pobranie nazwy użytkownika
    var username = mockUser.Object.Username;

    // Assert
    // Sprawdzenie, czy nazwa użytkownika pasuje do wzorca (słowo_liczba)
    Assert.Matches(@"^\w+_\d+$", username);
}

Assert.Multiple

Assert.Multiple pozwala na wykonanie wielu asercji w jednym bloku testu, zbierając wyniki z każdej asercji przed zgłoszeniem błędu. Jest to szczególnie przydatne w scenariuszach, gdzie chcemy przetestować wiele warunków bez przerwania testu po pierwszej napotkanej nieudanej asercji.

Prosty przykład:

[Fact]
public void ValidatesMultipleProperties()
{
    // Arrange
    var person = new Person { Name = "John Doe", Age = 30 };

    // Act & Assert
    Assert.Multiple(() =>
    {
        Assert.Equal("John Doe", person.Name);  // Sprawdzenie, czy imię się zgadza
        Assert.Equal(30, person.Age);           // Sprawdzenie, czy wiek się zgadza
    });
}

Assert.NotEmpty

Assert.NotEmpty służy do weryfikacji, że kolekcja nie jest pusta.

Prosty przykład:

[Fact]
public void ListIsNotEmpty()
{
    // Arrange
    // Tworzenie listy z jednym elementem
    var elements = new List<string> { "apple" };

    // Act & Assert
    // Potwierdzenie, że lista nie jest pusta
    Assert.NotEmpty(elements);
}

Przykład z mockowaniem:

[Fact]
public void ProductsAvailableForSale()
{
    // Arrange
    var mockProductRepository = new Mock<IProductRepository>();

    // Konfiguracja mocka, aby zwracał listę dostępnych produktów
    mockProductRepository
        .Setup(repo => repo.GetAvailableProducts())
        .Returns(new List<Product> { new Product { Name = "Laptop" } });

    // Tworzenie serwisu z zmockowanym repozytorium
    var productService = new ProductService(mockProductRepository.Object);

    // Act
    // Pobranie dostępnych produktów
    var products = productService.GetAvailableProducts();

    // Assert
    // Potwierdzenie, że lista produktów nie jest pusta
    Assert.NotEmpty(products);
}