Python: Pisanie testów i test-driven development

Czym są testy jednostkowe?

Testy jednostkowe (unit tests) to krótkie fragmenty kodu, które weryfikują poprawność działania pojedynczych funkcji, metod lub klas. Ich głównym celem jest upewnienie się, że poszczególne elementy aplikacji działają zgodnie z założeniami — w oderwaniu od reszty systemu.

Dzięki nim możemy błyskawicznie wykrywać błędy, zapobiegać regresjom i utrzymywać wysoką jakość projektu.

W praktyce testy jednostkowe są pierwszą linią obrony przed błędami, które mogłyby pojawić się po modyfikacjach kodu. W dobrze utrzymanym projekcie stanowią automatyczny mechanizm kontroli jakości.

Dlaczego warto pisać testy?

Pisanie testów wymaga dyscypliny, ale szybko się zwraca.

Dobrze zaprojektowany zestaw testów:

• pozwala bezpiecznie refaktoryzować kod,
• wykrywa błędy jeszcze zanim trafią do środowiska produkcyjnego,
• dokumentuje zachowanie systemu,
• zwiększa pewność przy wdrażaniu nowych funkcji.

W Pythonie testy są szczególnie proste do wdrożenia — dzięki wbudowanemu modułowi unittest oraz popularnym frameworkom jak pytest, które czynią testowanie intuicyjnym i przyjemnym procesem.

Podstawy pisania testów jednostkowych w Pythonie

1. Wbudowany moduł unittest

Python posiada wbudowany framework unittest, inspirowany rozwiązaniami znanymi z Javy (JUnit). Umożliwia tworzenie klas testowych, grupowanie przypadków testowych i wykonywanie ich automatycznie.

Przykład:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
import unittest

def suma(a, b):
    return a + b

class TestMatematyka(unittest.TestCase):
    def test_suma(self):
        self.assertEqual(suma(1, 2), 3)

if __name__ == '__main__':
    unittest.main()

Po uruchomieniu skryptu, Python sam wykona testy i poinformuje o ewentualnych błędach.

Dzięki takim testom możemy natychmiast wykryć problemy po każdej zmianie w kodzie.

2. Pytest — prostszy i bardziej elastyczny sposób testowania

pytest to obecnie najpopularniejszy framework testowy w świecie Pythona.

Nie wymaga dziedziczenia po żadnej klasie, pozwala pisać testy w zwykłych funkcjach i oferuje dziesiątki dodatków (pluginów) do pracy z mockami, bazami danych, testami integracyjnymi czy asynchronicznymi.

Przykład prostego testu w pytest:

Python
Kopiuj
1
2
3
4
5
def suma(a, b):
    return a + b

def test_suma():
    assert suma(1, 2) == 3

Uruchomienie testów:

Bash
Kopiuj
1
pytest

Wynik jest przejrzysty, kolorowy i pokazuje, które testy przeszły, a które zawiodły — wraz z kontekstem błędu.

Zalety korzystania z pytest:

• Krótsza i bardziej czytelna składnia niż w unittest.
• Obsługa parametryzacji testów – możesz jednym testem sprawdzić wiele przypadków.
• Integracja z CI/CD i wsparcie dla wtyczek.
• Doskonała współpraca z mock, coverage i pytest-cov do mierzenia pokrycia testami.

3. Parametryzacja testów w pytest

Jedną z najpotężniejszych funkcji pytest jest możliwość parametryzacji testów — uruchamianie tego samego testu z różnymi danymi wejściowymi.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
import pytest

def suma(a, b):
    return a + b

@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (0, 0, 0),
    (-1, 1, 0),
    (10, -5, 5),
])
def test_suma_parametrized(a, b, expected):
    assert suma(a, b) == expected

Ten jeden test sprawdzi wszystkie cztery przypadki automatycznie.

4. Organizacja testów w projekcie

Dobrą praktyką jest trzymanie testów w osobnym katalogu, np.:

Bash
Kopiuj
1
2
3
4
5
6
7
8
9
project/
│
├── app/
│ ├── __init__.py
│ └── core.py
│
└── tests/
├── __init__.py
└── test_core.py

Dzięki temu zachowujesz porządek, a framework testowy automatycznie wykryje i uruchomi wszystkie testy w folderze tests.

Podejście Test-Driven Development (TDD)

1. Na czym polega TDD?

Test-Driven Development (TDD) to metodologia, w której proces tworzenia oprogramowania opiera się na pisaniu testów przed implementacją właściwego kodu.

Kluczowa zasada:

Najpierw test, który zawiedzie. Potem kod, który sprawi, że test przejdzie.

Cykl TDD składa się z trzech kroków:

1. Red – napisz test, który nie przechodzi (brakuje implementacji).
2. Green – napisz minimalny kod, który pozwoli testowi przejść.
3. Refactor – uporządkuj kod, nie psując testów.

2. Przykład prostego cyklu TDD

Krok 1: Tworzymy test

Python
Kopiuj
1
2
def test_suma():
    assert suma(2, 3) == 5

Test nie przejdzie, bo funkcja suma jeszcze nie istnieje.

Krok 2: Implementujemy minimalny kod

Python
Kopiuj
1
2
def suma(a, b):
    return a + b

Teraz test powinien przejść.

Krok 3: Refaktoryzacja

Jeśli kod jest poprawny i test przeszedł, możesz go poprawić, zoptymalizować lub rozbudować — mając pewność, że nie złamiesz istniejącej logiki.

3. Dlaczego TDD działa?

TDD zmienia sposób myślenia o pisaniu kodu.

Zamiast „jak to zrobić", zaczynasz od „co ma działać" — skupiasz się na efekcie, a nie implementacji.

Korzyści z TDD:

• Zmusza do projektowania kodu z myślą o testowalności.
• Ułatwia rozbijanie problemów na małe, zrozumiałe kroki.
• Minimalizuje regresje przy refaktoryzacji.
• Wymusza tworzenie prostych, modularnych funkcji.
• Daje natychmiastową informację zwrotną o jakości kodu.

W praktyce TDD świetnie sprawdza się przy budowie API, modeli danych, algorytmów i wszędzie tam, gdzie precyzja logiki ma znaczenie.

Dobre praktyki przy pisaniu testów

• Jedna asercja na test — test powinien sprawdzać konkretną rzecz.
• Nazwy testów powinny mówić, co się dzieje (test_user_login_fails_without_password).
• Nie testuj bibliotek zewnętrznych — testuj tylko własny kod.
• Korzystaj z mocków i fixture'ów przy testach zależnych od API lub bazy danych.
• Automatyzuj uruchamianie testów — włącz je do CI/CD.
• Mierz pokrycie testami (coverage run -m pytest && coverage report).
• Traktuj testy jak dokumentację — pokazują, jak używać funkcji.

Mocki w pytest

Gdy funkcja zależy od zewnętrznych systemów (API, baza danych), użyj mocków:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
from unittest.mock import patch

def fetch_user(user_id):
    # symulacja wywołania API
    return {"id": user_id, "name": "Jan"}

@patch('module.api_call')
def test_fetch_user(mock_api):
    mock_api.return_value = {"id": 1, "name": "Jan"}
    result = fetch_user(1)
    assert result["name"] == "Jan"

Fixtures w pytest

Fixtures pozwalają na przygotowanie danych testowych:

Python
Kopiuj
1
2
3
4
5
6
7
8
import pytest

@pytest.fixture
def sample_user():
    return {"id": 1, "email": "test@example.com", "password": "secret"}

def test_user_creation(sample_user):
    assert sample_user["email"] == "test@example.com"

Rozszerzenia i narzędzia wspierające testowanie

• pytest-cov — mierzy pokrycie kodu testami.
• pytest-mock — ułatwia tworzenie obiektów zastępczych.
• hypothesis — generuje dane testowe automatycznie.
• tox — automatyzuje testy w różnych środowiskach i wersjach Pythona.
• CI/CD (GitHub Actions, GitLab CI) — pozwala automatycznie uruchamiać testy przy każdym commicie.

Przykład konfiguracji pytest-cov

Bash
Kopiuj
1
pytest --cov=app --cov-report=html

To uruchomi testy i wygeneruje raport pokrycia w formacie HTML.

Testowanie w praktyce: przykład z życia projektu

Załóżmy, że piszesz funkcję rejestracji użytkownika. Zamiast testować ją „na żywo", przygotowujesz testy:

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def test_register_user_success(client):
    response = client.post("/register", json={
        "email": "test@example.com",
        "password": "123456"
    })

    assert response.status_code == 201
    assert "user_id" in response.json()

def test_register_user_duplicate_email(client):
    client.post("/register", json={
    "email": "test@example.com",
    "password": "123456"
    })
    response = client.post("/register", json={
    "email": "test@example.com",
    "password": "123456"
    })

    assert response.status_code == 400

Dzięki temu po każdej zmianie w logice rejestracji — np. wprowadzeniu walidacji lub szyfrowania — możesz jednym poleceniem sprawdzić, czy nie złamałeś istniejącego przepływu.

Testowanie z użyciem mocków — przykład

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
from unittest.mock import Mock, patch

@patch('app.services.email.send_email')
def test_send_welcome_email(mock_send):
    mock_send.return_value = True

    user = create_user("test@example.com")
    send_welcome_email(user)

    mock_send.assert_called_once_with(
        to=user.email,
        subject="Witamy!"
    )

Podsumowanie

Pisanie testów jednostkowych w Pythonie to nie dodatek — to strategia utrzymania jakości kodu.

Frameworki takie jak pytest czy unittest sprawiają, że proces testowania jest prosty i zautomatyzowany, a podejście TDD podnosi poziom projektowania i bezpieczeństwa zmian.

Jeśli chcesz pisać kod, który nie tylko działa, ale też działa zawsze tak, jak trzeba, ucz się testów i włącz TDD do swojego workflow.

To krok od programisty, który „pisze kod", do inżyniera, który projektuje niezawodne oprogramowanie.

Chcesz dowiedzieć się więcej?

Jeśli chcesz pogłębić temat testów, zobacz kompletny przewodnik: 👉 Testowanie w Pythonie – jednostkowe, integracyjne i TDD