Zrozumienie Asercji w xUnit: Kluczowe Metody i Ich Zastosowanie

Zrozumienie Asercji w xUnit: Kluczowe Metody i Ich Zastosowanie
1 maja 2024 Brak komentarzy Testowanie Tajko

Assert.NotEqual

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

Prosty przykład:

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

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

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

Przykład z mockowaniem:

[Fact]
public void UserAgeIsNotEqualTo18()
{
    // Arrange
    var mockUserRepository = new Mock<IUserRepository>();
    
    // Konfiguracja mocka, aby zwracał użytkownika z wiekiem 20 lat
    mockUserRepository.Setup(repo => repo.FindById(1))
        .Returns(new User { Age = 20 });

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

    // Act
    // Pobranie użytkownika o id 1
    var user = userService.GetUserById(1);

    // Assert
    // Potwierdzenie, że wiek użytkownika nie jest równy 18
    Assert.NotEqual(18, user.Age);
}
Assert.NotInRange

Assert.NotInRange sprawdza, czy dana wartość nie znajduje się w określonym zakresie wartości.

Prosty przykład:

[Fact]
public void ValueIsNotInRange()
{
    // Arrange
    // Ustawienie wartości liczby
    int number = 5;

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

Przykład z mockowaniem:

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

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

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

    // Assert
    // Sprawdzenie, czy temperatura nie znajduje się w bezpiecznym zakresie
    Assert.NotInRange(temp, 0, 50);
}
Assert.NotNull

Assert.NotNull sprawdza, czy obiekt nie jest równy null.

Prosty przykład:

[Fact]
public void ObjectIsNotNull()
{
    // Arrange
    // Tworzenie obiektu
    object obj = new();

    // Act & Assert
    // Sprawdzenie, czy obiekt nie jest null
    Assert.NotNull(obj);
}

Przykład z mockowaniem:

[Fact]
public void ServiceReturnsNotNullUser()
{
    // Arrange
    var mockUserService = new Mock<IUserService>();
    // Konfiguracja mocka zwracającego użytkownika
    mockUserService.Setup(s => s.GetUserById(1)).Returns(new User());

    // Act
    // Pobranie użytkownika
    var user = mockUserService.Object.GetUserById(1);

    // Assert
    // Sprawdzenie, czy zwrócony użytkownik nie jest null
    Assert.NotNull(user);
}
Assert.NotSame

Assert.NotSame weryfikuje, że dwa obiekty nie są tym samym obiektem (tj. nie mają tej samej referencji).

Prosty przykład:

[Fact]
public void ObjectsAreNotTheSame()
{
    // Arrange
    var object1 = new Object(); // Tworzenie pierwszego obiektu
    var object2 = new Object(); // Tworzenie drugiego obiektu

    // Act & Assert
    Assert.NotSame(object1, object2); // Sprawdzenie, czy to nie są te same obiekty
}
Assert.NotStrictEqual

Assert.NotStrictEqual sprawdza, że dwa obiekty lub wartości nie są identyczne, z uwzględnieniem różnic, które mogą być ignorowane w prostym porównaniu, takie jak różnice w typach, referencjach czy konwersjach niejawnych.

Prosty przykład:

[Fact]
public void ValuesAreNotStrictlyEqual()
{
    // Arrange
    string numberAsString = "5";
    int number = 5;

    // Act & Assert
    // Sprawdzenie, czy wartości nie są ściśle równe
    Assert.NotStrictEqual(numberAsString, number);
}
Assert.Null

Assert.Null sprawdza, czy dany obiekt jest równy null.

Prosty przykład:

[Fact]
public void ObjectIsNull()
{
    // Arrange
    // Ustawienie obiektu na null
    object obj = null;

    // Act & Assert
    // Sprawdzenie, czy obiekt jest null
    Assert.Null(obj);
}

Przykład z mockowaniem:

[Fact]
public void GetUserReturnsNull()
{
    // Arrange
    var mockUserService = new Mock<IUserService>();
    
    // Konfiguracja mocka zwracającego null dla danego identyfikatora
    mockUserService.Setup(s => s.GetUserById(1)).Returns((User)null);

    // Act
    // Pobranie użytkownika
    var user = mockUserService.Object.GetUserById(1);

    // Assert
    // Sprawdzenie, czy zwrócony użytkownik jest null
    Assert.Null(user);
}
Assert.ProperSubset

Assert.ProperSubset weryfikuje, czy jedna kolekcja jest prawdziwym podzbiorem drugiej kolekcji.

Prosty przykład:

[Fact]
public void CollectionIsProperSubset()
{
    // Arrange
    var subset = new HashSet<int> { 1, 2 };      // Definicja prawdziwego podzbioru
    var superset = new HashSet<int> { 1, 2, 3 }; // Definicja nadrzędnego zbioru

    // Act & Assert
    // Sprawdzenie, czy pierwszy zbiór jest prawdziwym podzbiorem drugiego zbioru
    Assert.ProperSubset(subset, superset); 
}

Przykład z mockowaniem:

Nie jest typowo używany, ponieważ testowanie kolekcji rzadko wymaga mockowania.

Assert.ProperSuperset

Assert.ProperSuperset weryfikuje, czy jedna kolekcja jest prawdziwym nadzbiorem drugiej kolekcji.

Prosty przykład:

[Fact]
public void CollectionIsProperSuperset()
{
    // Arrange
    var subset = new HashSet<int> { 1, 2 };         // Definicja podzbioru
    var superset = new HashSet<int> { 1, 2, 3 };    // Definicja nadrzędnego zbioru

    // Act & Assert
    // Sprawdzenie, czy pierwszy zbiór jest prawdziwym nadzbiorem drugiego zbioru
    Assert.ProperSuperset(superset, subset);
}
Assert.PropertyChanged

Assert.PropertyChanged jest używane do testowania, czy zdarzenie zmiany właściwości (PropertyChanged) jest wywoływane dla określonej właściwości obiektu, gdy oczekuje się, że jej wartość uległa zmianie.

Prosty przykład:

[Fact]
public void PropertyChangesWhenValueUpdated()
{
    // Arrange
    // Tworzenie obiektu z właściwościami powiadamiającymi o zmianie
    var model = new ObservableObject();

    // Act & Assert
    // Sprawdzenie, czy zmiana właściwości 'Name' wywoła zdarzenie PropertyChanged
    Assert.PropertyChanged(model, "Name", () => model.Name = "Nowe imię");
}

Przykład z mockowaniem:

[Fact]
public void TestPropertyChangedWithMock()
{
    // Arrange
    // Tworzenie mocka obiektu
    var mockViewModel = new Mock<ObservableObject>();
    string newName = "Nowe imię";

    // Act
    // Ustawienie nowej wartości
    mockViewModel.Object.Name = newName;

    // Assert
    // Symulowanie zgłoszenia zdarzenia PropertyChanged
    mockViewModel.Raise(m => m.PropertyChanged += null, new PropertyChangedEventArgs("Name"));

    // Dodatkowe sprawdzenie, czy właściwość została zaktualizowana
    Assert.Equal(newName, mockViewModel.Object.Name);
}
Assert.PropertyChangedAsync

Assert.PropertyChangedAsync to asynchroniczna wersja Assert.PropertyChanged, używana do testowania zdarzeń zmiany właściwości w scenariuszach asynchronicznych.

Prosty przykład:

 [Fact]
 public async Task PropertyChangesWhenValueUpdatedAsync()
 {
     // Arrange
     // Tworzenie modelu z właściwościami powiadamiającymi o zmianie
     var model = new ObservableObject();

     // Act & Assert
     // Sprawdzenie, czy zmiana właściwości 'Name' wywoła zdarzenie PropertyChanged
     await Assert.PropertyChangedAsync(model, "Name", async () =>
     {
         // Asynchroniczna zmiana właściwości 'Name'
         await Task.Run(() => model.Name = "Nowe imię"); 
     });
 }

Przykład z mockowaniem:

[Fact]
public async Task TestPropertyChangedAsyncWithMock()
{
    // Arrange
    // Tworzenie mocka obiektu
    var mockViewModel = new Mock<ObservableObject>();
    string newName = "Nowa nazwa asynchroniczna";

    // Act
    // Asynchroniczne ustawienie nowej wartości
    await Task.Run(() => mockViewModel.Object.Name = newName);

    // Assert
    // Symulowanie zgłoszenia zdarzenia PropertyChanged
    mockViewModel.Raise(m => m.PropertyChanged += null, new PropertyChangedEventArgs("Name"));

    // Dodatkowe sprawdzenie, czy właściwość została zaktualizowana
    Assert.Equal(newName, mockViewModel.Object.Name);
}
Tagi
O Autorze
Tajko
Tajko Tajko z tej strony:) Obecnie pracuję we Wrocławiu przy projektach desktopowych. Skoro sam się czegoś nauczyłem to i inni mogliby nauczyć się tego co ja w łopatologiczny sposób:)

ZOSTAW ODPOWIEDŹ