Testy jednostkowe w C# – MSTest

Wstęp – po co testy jednostkowe?

Testy jednostkowe (ang. Unit Tests) to małe fragmenty kodu, które automatycznie sprawdzają, czy pojedyncza funkcja/metoda działa poprawnie.

Dlaczego są ważne?

Przykład z życia – kalkulator

❌ Bez testów:

✅ Z testami:

Co to jest MSTest?

MSTest to framework wbudowany w Visual Studio, który służy do pisania testów jednostkowych w C#. Microsoft go stworzył specjalnie dla .NET.

Atrybuty MSTest

W testach używamy specjalnych atrybutów – to adnotacje przed klasą lub metodą:

Konfiguracja projektu testowego

Krok 1: Utwórz projekt główny

1. Otwórz Visual Studio
2. File → New → Project
3. Wybierz Console App (.NET)
4. Nazwa: CalculatorApp
5. Kliknij Create

Krok 2: Dodaj projekt testowy

1. Kliknij prawym przyciskiem na Solution (w Solution Explorer)
2. Add → New Project
3. Wyszukaj: MSTest Test Project
4. Nazwa: CalculatorApp.Tests
5. Kliknij Create

Krok 3: Dodaj referencję do projektu głównego

1. W Solution Explorer, rozwiń projekt CalculatorApp.Tests
2. Kliknij prawym na Dependencies → Add Project Reference
3. Zaznacz CalculatorApp
4. Kliknij OK

Krok 4: Struktura projektu

Krok 5: Sprawdź, czy działa

W pliku CalculatorTests.cs dodaj na górze:

using CalculatorApp;  // Jeśli się podkreśla na czerwono = brak referencji!

Test Explorer – centrum dowodzenia

Test Explorer to okno w Visual Studio, gdzie widzisz wszystkie testy i możesz je uruchamiać.

Jak otworzyć Test Explorer?

• Metoda 1: Test → Test Explorer
• Metoda 2: Ctrl + E, T

Co zobaczysz w Test Explorer?

Co to jest asercja?

Asercja (ang. assertion) to instrukcja sprawdzająca, czy wynik działania programu jest taki, jak oczekiwany.

Assert.AreEqual(5, wynik);

// ✅ Test przechodzi, jeśli wynik == 5
// ❌ Test nie przechodzi, jeśli wynik != 5

Najważniejsze asercje

Kod programu do testowania

Stwórzmy prostą klasę Calculator w projekcie głównym.

namespace CalculatorApp
{
    public class Calculator
    {
        public static int Dodaj(int a, int b)
        {
            return a + b;
        }

        public static int Odejmij(int a, int b)
        {
            return a - b;
        }

        public static int Pomnoz(int a, int b)
        {
            return a * b;
        }

        public static double Podziel(int a, int b)
        {
            if (b == 0)
            {
                throw new DivideByZeroException("Nie można dzielić przez zero!");
            }
            return (double)a / b;
        }

        public static string GenerujKomunikat(int a, int b, int wynik)
        {
            return $"Suma {a} + {b} = {wynik}";
        }
    }
}

Pierwszy test – wzorzec AAA

Każdy dobry test składa się z trzech sekcji: Arrange → Act → Assert.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using CalculatorApp;

namespace CalculatorApp.Tests
{
    [TestClass]
    public class CalculatorTests
    {
        [TestMethod]
        public void Dodaj_DwieLiczbyDodatnie_ZwracaSume()
        {
            // Arrange (przygotowanie danych)
            int a = 2;
            int b = 3;
            int oczekiwanyWynik = 5;

            // Act (wykonanie metody)
            int wynik = Calculator.Dodaj(a, b);

            // Assert (sprawdzenie wyniku)
            Assert.AreEqual(oczekiwanyWynik, wynik);
        }
    }
}

Uruchamianie testów

1. Otwórz Test Explorer (Ctrl + E, T)
2. Kliknij Run All (zielona strzałka ▶️)
3. Poczekaj 1-2 sekundy

Debugowanie testów

Jeśli test nie przechodzi i nie wiesz dlaczego:

1. Postaw breakpoint (F9) w linii z asercją
2. Kliknij prawym na test → Debug
3. Program zatrzyma się na breakpoincie – możesz podejrzeć wartości zmiennych

Różne przypadki testowe

Dobry programista testuje wiele scenariuszy, nie tylko „happy path” (idealny przypadek).

Test z liczbami ujemnymi

[TestMethod]
public void Dodaj_DwieLiczbyUjemne_ZwracaSume()
{
    // Arrange
    int a = -5;
    int b = -3;

    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(-8, wynik);
}

Test z zerem

[TestMethod]
public void Dodaj_JednaLiczbaZero_ZwracaDrugaLiczbe()
{
    // Arrange
    int a = 0;
    int b = 7;

    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(7, wynik);
}

Test mnożenia

[TestMethod]
public void Pomnoz_DwieLiczby_ZwracaIloczyn()
{
    // Arrange
    int a = 4;
    int b = 5;

    // Act
    int wynik = Calculator.Pomnoz(a, b);

    // Assert
    Assert.AreEqual(20, wynik);
}

Testowanie wyjątków

Czasami oczekujemy, że kod RZUCI WYJĄTEK (np. dzielenie przez zero). MSTest pozwala to przetestować!

Przykład: dzielenie przez zero

[TestMethod]
public void Podziel_PrzezZero_RzucaWyjatek()
{
    // Arrange
    int a = 10;
    int b = 0;

    // Act & Assert (w jednej linii!)
    Assert.ThrowsException<DivideByZeroException>(() =>
    {
        Calculator.Podziel(a, b);
    });
}

Test dzielenia z resztą (delta)

[TestMethod]
public void Podziel_ZReszta_ZwracaWartoscZmiennoprzecinkowa()
{
    // Arrange
    int a = 10;
    int b = 3;

    // Act
    double wynik = Calculator.Podziel(a, b);

    // Assert - delta = dopuszczalny błąd zaokrąglenia
    Assert.AreEqual(3.333, wynik, 0.001);
}

Testy parametryzowane (DataRow)

Zamiast pisać wiele podobnych testów, możemy użyć jednego testu z wieloma zestawami danych.

[DataTestMethod]
[DataRow(2, 3, 5)]
[DataRow(7, 3, 10)]
[DataRow(-5, 5, 0)]
[DataRow(0, 0, 0)]
[DataRow(100, 200, 300)]
public void Dodaj_RozneWartosci_ZwracaPoprawnaSume(int a, int b, int oczekiwany)
{
    // Act
    int wynik = Calculator.Dodaj(a, b);

    // Assert
    Assert.AreEqual(oczekiwany, wynik);
}

Jak to działa?

• [DataTestMethod] – zamiast [TestMethod]
• [DataRow(a, b, oczekiwany)] – każdy wiersz to jeden test
• MSTest uruchomi metodę 5 razy (dla każdego DataRow)
• W Test Explorer zobaczysz 5 osobnych testów!

Testowanie komunikatów tekstowych

Często w programie wyświetlamy komunikaty użytkownikowi. Możemy to też testować!

[TestMethod]
public void GenerujKomunikat_DwieLiczby_ZwracaPoprawnyTekst()
{
    // Arrange
    int a = 5;
    int b = 3;
    int wynik = 8;

    // Act
    string komunikat = Calculator.GenerujKomunikat(a, b, wynik);

    // Assert
    Assert.AreEqual("Suma 5 + 3 = 8", komunikat);
}

Test komunikatu z DataRow

[DataTestMethod]
[DataRow(2, 3, 5, "Suma 2 + 3 = 5")]
[DataRow(0, 0, 0, "Suma 0 + 0 = 0")]
[DataRow(-1, 1, 0, "Suma -1 + 1 = 0")]
public void GenerujKomunikat_RozneWartosci(int a, int b, int wynik, string oczekiwany)
{
    // Act
    string komunikat = Calculator.GenerujKomunikat(a, b, wynik);

    // Assert
    Assert.AreEqual(oczekiwany, komunikat);
}

Częste błędy

❌ Błąd 1: Brak atrybutów [TestClass] lub [TestMethod]

Test Explorer nie widzi testów, bo klasa lub metoda nie jest oznaczona.

❌ Błąd 2: Brak referencji do projektu głównego

Visual Studio podkreśla using CalculatorApp; na czerwono.

❌ Błąd 3: Zła kolejność argumentów w AreEqual

❌ Błąd 4: [TestMethod] zamiast [DataTestMethod]

Przy testach parametryzowanych z [DataRow] musisz użyć [DataTestMethod]!

❌ Błąd 5: Porównywanie double bez delta

❌ Błąd 6: Testy zależne od siebie

Jeden test ustawia zmienną, a drugi z niej korzysta. Kolejność wykonania testów nie jest gwarantowana!

Dobre praktyki

1. Konwencja nazewnictwa testów

Wzorzec: NazwaMetody_Scenariusz_OczekiwaneZachowanie

2. Jeden assert na test (w miarę możliwości)

Jeśli pierwszy assert nie przejdzie, pozostałe się nie wykonają – nie dowiesz się, co jeszcze jest zepsute.

3. Testuj przypadki brzegowe

4. Testy muszą być niezależne

Każdy test powinien działać samodzielnie. Nie polegaj na kolejności wykonywania!

5. Testy powinny być szybkie

⚡ Jeden test powinien wykonywać się w milisekundach, nie sekundach!

6. Używaj [TestInitialize]

Jeśli wiele testów potrzebuje tych samych danych:

[TestClass]
public class CalculatorTests
{
    private Calculator kalkulator;

    [TestInitialize]
    public void Setup()
    {
        // Wykonywane przed KAŻDYM testem
        kalkulator = new Calculator();
    }

    [TestMethod]
    public void Test1() { /* użyj kalkulator */ }

    [TestMethod]
    public void Test2() { /* użyj kalkulator */ }
}

Zadania praktyczne

public static int Poteguj(int podstawa, int wykladnik)
{
    return (int)Math.Pow(podstawa, wykladnik);
}

public static bool CzyParzysta(int liczba)
{
    return liczba % 2 == 0;
}

public static int Pierwiastek(int liczba)
{
    if (liczba < 0)
    {
        throw new ArgumentException("Nie można obliczyć pierwiastka z liczby ujemnej!");
    }
    return (int)Math.Sqrt(liczba);
}

public static bool CzyWiekPoprawny(int wiek)
{
    return wiek >= 0 && wiek <= 150;
}

public class StringHelper
{
    public static string Odwroc(string tekst) { /* TODO */ }
    public static int IleLiter(string tekst) { /* TODO */ }
    public static bool CzyPalindrom(string tekst) { /* TODO */ }
}