Zrozumienie Asercji w xUnit: Kluczowe Metody i Ich Zastosowanie

Przykłady

Assert.All

Metoda Assert.All sprawdza, czy każdy element kolekcji spełnia określone kryterium wyrażone przez delegat przekazany jako drugi argument.

Prosty przykład:

[Fact]
public void AllItemsArePositive()
{
    // Arrange
    // Tworzenie listy liczb całkowitych
    var numbers = new List<int> { 1, 2, 3 };

    // Act & Assert
    // Sprawdzenie, czy wszystkie liczby są dodatnie
    Assert.All(numbers, item => Assert.True(item > 0)); 
}

Przykład z mockowaniem:

[Fact]
public void AllUsersAreAdults()
{
    // Arrange
    var mockUserRepository = new Mock<IUserRepository>();

    // Konfiguracja mocka, aby zwracał listę dorosłych użytkowników
    mockUserRepository.Setup(repo => repo.GetAllUsers())
        .Returns(new List<User> { new User { Age = 21 }, new User { Age = 22 } });

    // Tworzenie serwisu z zmockowanym repozytorium
    var userService = new UserService(mockUserRepository.Object);

    // Act
    // Pobranie wszystkich użytkowników
    var users = userService.GetAllUsers();

    // Assert
    // Sprawdzenie, czy wszyscy użytkownicy są dorośli
    Assert.All(users, user => Assert.True(user.Age >= 18));
}

Assert.Collection

Assert.Collection służy do weryfikacji, że kolekcja zawiera elementy spełniające określone warunki w danej kolejności.

Prosty przykład:

[Fact]
public void CollectionHasSpecificItems()
{
    // Arrange
    // Tworzenie listy owoców
    var fruits = new List<string> { "apple", "banana", "cherry" };

    // Act & Assert
    Assert.Collection(fruits,
        item => Assert.Equal("apple", item),    // Sprawdzenie, czy pierwszy element to "apple"
        item => Assert.Equal("banana", item),   // Sprawdzenie, czy drugi element to "banana"
        item => Assert.Equal("cherry", item));  // Sprawdzenie, czy trzeci element to "cherry"
}

Przykład z mockowaniem:

[Fact]
public void UsersHaveSpecificRoles()
{
    // Arrange
    var mockUserRepository = new Mock<IUserRepository>();
    // Konfiguracja mocka, aby zwracał użytkowników z określonymi rolami
    mockUserRepository
        .Setup(repo => repo.GetAllUsers())
        .Returns(new List<User> 
            { 
                new User { Role = "Admin" }, 
                new User { Role = "User" } 
            });

    // Tworzenie serwisu z zmockowanym repozytorium
    var userService = new UserService(mockUserRepository.Object);

    // Act
    // Pobranie wszystkich użytkowników
    var users = userService.GetAllUsers();

    // Assert
    Assert.Collection(users,
        user => Assert.Equal("Admin", user.Role), // Sprawdzenie, czy pierwszy użytkownik to admin
        user => Assert.Equal("User", user.Role)); // Sprawdzenie, czy drugi użytkownik to zwykły użytkownik
}

Assert.Contains

Assert.Contains jest używane do sprawdzenia, czy kolekcja zawiera określony element.

Prosty przykład:

[Fact]
public void ListContainsElement()
{
    // Arrange
    // Tworzenie listy elementów
    var elements = new List<string> { "apple", "banana", "cherry" };

    // Act & Assert
    // Potwierdzenie, że lista zawiera 'banana'
    Assert.Contains("banana", elements);
}

Przykład z mockowaniem:

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

    // Konfiguracja mocka, aby zwracał produkty
    mockProductRepository
        .Setup(repo => repo.GetAllProducts())
        .Returns(new List<Product> 
            { 
                new Product { Name = "Laptop" }, 
                new Product { Name = "Phone" } 
            });

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

    // Act
    // Pobranie wszystkich produktów
    var products = productService.GetAllProducts();

    // Assert
    // Potwierdzenie, że lista produktów zawiera "Laptop"
    Assert.Contains(products, product => product.Name == "Laptop");
}

Assert.Distinct

Assert.Distinct sprawdza, czy wszystkie elementy w kolekcji są unikalne.

Prosty przykład:

[Fact]
public void NumbersAreUnique()
{
    // Arrange
    // Tworzenie listy liczb
    var numbers = new List<int> { 1, 2, 3 };

    // Act & Assert
    // Sprawdzenie, czy wszystkie liczby są unikalne
    Assert.Distinct(numbers);
}

Przykład z mockowaniem:

[Fact]
public void UserEmailsAreUnique()
{
    // Arrange
    var mockUserRepository = new Mock<IUserRepository>();

    // Konfiguracja mocka, aby zwracał użytkowników z unikalnymi adresami e-mail
    mockUserRepository
        .Setup(repo => repo.GetAllUsers())
        .Returns(new List<User> 
            { 
                new User { Email = "user1@example.com" }, 
                new User { Email = "user2@example.com" } 
            });

    // Tworzenie serwisu z zmockowanym repozytorium
    var userService = new UserService(mockUserRepository.Object);

    // Act
    // Pobranie e-maili wszystkich użytkowników
    var emails = userService.GetAllUsers().Select(u => u.Email).ToList();

    // Assert
    // Sprawdzenie, czy wszystkie e-maile są unikalne
    Assert.Distinct(emails);
}

Assert.DoesNotContain

Assert.DoesNotContain jest używane do sprawdzenia, czy kolekcja nie zawiera określonego elementu.

Prosty przykład:

[Fact]
public void ListDoesNotContainElement()
{
    // Arrange
    // Tworzenie listy elementów
    var elements = new List<string> { "apple", "banana", "cherry" };

    // Act & Assert
    // Potwierdzenie, że lista nie zawiera 'orange'
    Assert.DoesNotContain("orange", elements);
}

Przykład z mockowaniem:

[Fact]
public void DiscontinuedProductsDoNotIncludeProduct()
{
    // Arrange
    var mockProductRepository = new Mock<IProductRepository>();
    
    // Konfiguracja mocka, aby zwracał wycofane produkty
    mockProductRepository
        .Setup(repo => repo.GetDiscontinuedProducts())
        .Returns(new List<Product> 
            { 
                new Product { Name = "OldPhone" } 
            });

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

    // Act
    // Pobranie wycofanych produktów
    var products = productService.GetDiscontinuedProducts();

    // Assert
    // Potwierdzenie, że lista wycofanych produktów nie zawiera "Phone"
    Assert.DoesNotContain(products, product => product.Name == "Phone");
}

Assert.DoesNotMatch

Assert.DoesNotMatch sprawdza, czy dany tekst nie pasuje do określonego wzorca wyrażenia regularnego.

Prosty przykład:

[Fact]
public void TextDoesNotMatchPattern()
{
    // Arrange
    // Definiowanie ciągu wejściowego
    string input = "Hello World!";

    // Act & Assert
    // Sprawdzenie, czy tekst nie pasuje do wzorca (same cyfry)
    Assert.DoesNotMatch("^[0-9]*$", input);
}

Przykład z mockowaniem:

[Fact]
public void UsernameDoesNotContainIllegalChars()
{
    // Arrange
    var mockUser = new Mock<IUser>();

    // Konfiguracja mocka zwracającego nazwę użytkownika
    mockUser.Setup(u => u.Username).Returns("JohnDoe123");

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

    // Assert
    // Sprawdzenie, czy nazwa użytkownika nie zawiera niedozwolonych znaków
    Assert.DoesNotMatch("[:*?<>|]+", username);
}

Assert.Empty

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

Prosty przykład:

[Fact]
public void ListIsEmpty()
{
    // Arrange
    // Tworzenie pustej listy elementów
    var elements = new List<string>();

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

Przykład z mockowaniem:

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

    // Konfiguracja mocka, aby zwracał pustą listę produktów
    mockProductRepository
        .Setup(repo => repo.GetAllProducts())
        .Returns(new List<Product>());

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

    // Act
    // Pobranie wszystkich produktów
    var products = productService.GetAllProducts();

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

Assert.EndsWith

Assert.EndsWith weryfikuje, czy ciąg tekstowy kończy się na określony podciąg.

Prosty przykład:

[Fact]
public void StringEndsWithSuffix()
{
    // Arrange
    // Definiowanie ciągu
    string value = "unittest";

    // Act & Assert
    // Potwierdzenie, że ciąg kończy się na 'test'
    Assert.EndsWith("test", value);
}

Przykład z mockowaniem:

[Fact]
public void FilePathHasCorrectExtension()
{
    // Arrange
    var mockFile = new Mock<IFile>();

    // Konfiguracja mocka zwracającego ścieżkę do pliku
    mockFile.Setup(f => f.Path).Returns("report.pdf");

    // Act
    // Pobranie ścieżki pliku
    var path = mockFile.Object.Path;

    // Assert
    // Sprawdzenie, czy ścieżka pliku kończy się na .pdf
    Assert.EndsWith(".pdf", path);
}

Assert.Equal

Assert.Equal sprawdza, czy dwa obiekty są równe.

Prosty przykład:

[Fact]
public void ValuesAreEqual()
{
    // Arrange
    // Oczekiwana wartość
    int expected = 5;

    // Act
    // Rzeczywista wartość
    int actual = 5;

    // Assert
    // Potwierdzenie, że wartości są równe
    Assert.Equal(expected, actual);
}

Przykład z mockowaniem:

[Fact]
public void CorrectNumberOfUsersReturned()
{
    // Arrange
    var mockUserRepository = new Mock<IUserRepository>();

    // Konfiguracja mocka, aby zwracał listę dwóch użytkowników
    mockUserRepository
        .Setup(repo => repo.GetAllUsers())
        .Returns(new List<User> 
        { 
            new User(), 
            new User() 
        });

    // Tworzenie serwisu z zmockowanym repozytorium
    var userService = new UserService(mockUserRepository.Object);

    // Act
    // Pobranie wszystkich użytkowników
    var users = userService.GetAllUsers();

    // Assert
    // Potwierdzenie, że liczba użytkowników wynosi 2
    Assert.Equal(2, users.Count);
}

Assert.Equivalent

Assert.Equivalent sprawdza, czy dwie kolekcje zawierają te same elementy, niekoniecznie w tej samej kolejności.

Prosty przykład:

[Fact]
public void CollectionsAreEquivalent()
{
    // Arrange
    var expected = new List<int> { 1, 2, 3 };   // Definiowanie oczekiwanej kolekcji
    var actual = new List<int> { 3, 1, 2 };     // Definiowanie rzeczywistej kolekcji

    // Act & Assert
    Assert.Equivalent(expected, actual);        // Potwierdzenie, że kolekcje są równoważne
}

Przykład z mockowaniem:

[Fact]
public void UserHasCorrectRoles()
{
    // Arrange
    var mockUser = new Mock<IUser>();
    
    // Konfiguracja mocka zwracającego role użytkownika
    mockUser.Setup(u => u.Roles).Returns(new List<string> { "admin", "user" });

    // Definiowanie oczekiwanych ról
    var expectedRoles = new List<string> { "user", "admin" };

    // Act
    // Pobranie ról użytkownika
    var roles = mockUser.Object.Roles;

    // Assert
    // Sprawdzenie, czy użytkownik ma odpowiednie role
    Assert.Equivalent(expectedRoles, roles);
}