Testy jednostkowe napisane przez AI często przechodzą i dają wysokie pokrycie kodu, a mimo to sprawdzają za mało: typ zamiast wartości, jedną gałąź, bez wartości granicznych. Najszybciej wykryjesz to testami mutacyjnymi: narzędzie takie jak mutmut wprowadza do kodu drobne błędy (mutanty) i sprawdza, czy testy je wyłapią. W naszym przykładzie testy ze 100% pokrycia przepuściły 8 z 14 mutantów, a po poprawkach wyłapały wszystkie.
Poprosisz asystenta AI o testy, dostajesz cztery zielone testy i raport pokrycia 100%. Wygląda na zrobione. Problem w tym, że test, który przechodzi, mówi tylko tyle, że kod się nie wywraca, a nie że robi to, co powinien. W tym artykule bierzemy małą funkcję w Pythonie, testy w stylu typowym dla AI i sprawdzamy je narzędziem do testów mutacyjnych, mutmut. Wszystkie wyniki poniżej pochodzą z prawdziwego uruchomienia (Python 3.13, pytest 9.2, mutmut 3.8).
Dlaczego testy wygenerowane przez AI mogą przechodzić i niczego nie sprawdzać?
Model pisze testy na podstawie kodu, który widzi. Jeśli w kodzie jest błąd, test często go „utrwala”, bo opisuje to, co kod robi, a nie to, co powinien robić. Do tego dochodzą powtarzalne wzorce słabych asercji:
| Wzorzec w teście | Przykład | Czego nie wyłapie |
|---|---|---|
| Sprawdzanie typu zamiast wartości | assert isinstance(result, float) | złej kwoty, złego wzoru |
| Porównanie względne | assert a > b | tego, że obie wartości są złe |
| Tylko „szczęśliwa ścieżka” | jeden test dla typowych danych | błędów na granicach i w rzadkich gałęziach |
| Brak wartości granicznych | test dla 500, nie dla 200 | >= zamienionego na > |
| Sam fakt wyjątku | pytest.raises(ValueError) bez komunikatu | rzucenia wyjątku z innego powodu |
| Mockowanie wszystkiego | mock zwraca to, co test sprawdza | niczego, test sprawdza sam siebie |
Część tych problemów widać już w code review, o czym piszemy w artykule o tym, jak recenzować kod napisany przez AI. Ale przy kilkudziesięciu testach łatwo coś przeoczyć. Testy mutacyjne robią to sprawdzanie automatycznie.
Czy 100% pokrycia kodu oznacza dobre testy?
Nie. Pokrycie kodu (coverage) mówi, które linie zostały wykonane podczas testów, a nie czy jakikolwiek test sprawdził ich wynik. Zobacz to na przykładzie. Funkcja liczy koszt dostawy w sklepie:
FREE_SHIPPING_THRESHOLD = 200
BASE_COST = 15
EXPRESS_SURCHARGE = 10
def shipping_cost(order_total: float, express: bool = False) -> float:
"""Zwraca koszt dostawy w złotych."""
if order_total < 0:
raise ValueError("Kwota zamówienia nie może być ujemna")
cost = 0 if order_total >= FREE_SHIPPING_THRESHOLD else BASE_COST
if express:
cost += EXPRESS_SURCHARGE
return cost
A tak wyglądają testy, jakie często dostajesz od asystenta AI:
import pytest
from shop.shipping import shipping_cost
def test_shipping_cost_returns_number():
assert isinstance(shipping_cost(100), (int, float))
def test_free_shipping_for_big_orders():
assert shipping_cost(500) == 0
def test_express_costs_more():
assert shipping_cost(100, express=True) > shipping_cost(100)
def test_negative_total_raises():
with pytest.raises(ValueError):
shipping_cost(-1)
Wszystkie przechodzą, a pytest --cov pokazuje komplet:
Name Stmts Miss Cover Missing
----------------------------------------------------
src/shop/__init__.py 0 0 100%
src/shop/shipping.py 10 0 100%
----------------------------------------------------
TOTAL 10 0 100%
4 passed in 0.02s
Zwróć uwagę, że żaden test nie sprawdza, czy zwykła dostawa kosztuje 15 zł. Raport pokrycia tego nie pokaże.
Czym są testy mutacyjne (mutation testing)?
Testy mutacyjne (mutation testing) sprawdzają testy, a nie kod. Narzędzie robi wiele kopii Twojego kodu i w każdej wprowadza jedną drobną zmianę, np. zamienia < na <= albo True na False. Taka zmieniona wersja to mutant. Potem dla każdego mutanta uruchamia testy:
- jeśli któryś test nie przejdzie, mutant jest zabity (killed), czyli testy wyłapały błąd,
- jeśli wszystkie przejdą, mutant przeżył (survived), czyli w tym miejscu możesz wprowadzić błąd i nikt się nie dowie.
Odsetek zabitych mutantów to wynik mutacyjny (mutation score). Najczęstsze mutacje wyglądają tak:
| Mutacja | Oryginał | Mutant |
|---|---|---|
| Operator porównania | if total < 0: | if total <= 0: |
| Stała liczbowa | if total < 0: | if total < 1: |
| Warunek logiczny | if a >= b | if (a >= b) or True |
| Wartość domyślna | express=False | express=True |
| Napis | "Kwota…" | "XXKwota…XX" albo None |
Jak uruchomić mutmut w projekcie Pythona?
mutmut to najprostsze narzędzie do testów mutacyjnych w Pythonie i współpracuje z pytestem. Instalacja:
pip install pytest mutmut
Konfiguracja w pyproject.toml dla układu z katalogiem src:
[tool.pytest.ini_options]
pythonpath = ["src"]
testpaths = ["tests"]
[tool.mutmut]
source_paths = ["src/shop/"]
pytest_add_cli_args_test_selection = ["tests/"]
Uruchomienie i lista przeżytych mutantów:
mutmut run
mutmut results
Trzy rzeczy, na które najczęściej trafiają osoby zaczynające z mutmut:
- Stare nazwy opcji. W mutmut 3 opcja
paths_to_mutatenazywa sięsource_paths, atests_dirzastąpiłopytest_add_cli_args_test_selection. Stare nazwy działają, ale wypisują ostrzeżenie. Jeśli mutmut nie może znaleźć kodu, zacznij od sprawdzeniasource_paths. Wiele poradników w sieci opisuje jeszcze mutmut 2, który miał inne polecenia. - pytest zbiera testy z katalogu
mutants. mutmut kopiuje projekt do katalogumutants/. Beztestpaths = ["tests"]zwykłepytestpo uruchomieniu mutmut kończy się błędemimport file mismatch, bo widzi dwa plikitest_shipping.py. Dopisz teżmutants/do.gitignore. - Windows. mutmut 3 wymaga systemowego
fork, więc na Windows uruchomisz go tylko w WSL.
mutmut 3 mutuje kod wewnątrz funkcji. Stałe na poziomie modułu, takie jak BASE_COST, zostają bez zmian, więc nie zobaczysz dla nich mutantów.
Co pokazały przeżyte mutanty?
Dla naszej funkcji mutmut wygenerował 14 mutantów. Przy testach od AI przeżyło 8:
shop.shipping.x_shipping_cost__mutmut_2: survived
shop.shipping.x_shipping_cost__mutmut_3: survived
shop.shipping.x_shipping_cost__mutmut_4: survived
shop.shipping.x_shipping_cost__mutmut_5: survived
shop.shipping.x_shipping_cost__mutmut_6: survived
shop.shipping.x_shipping_cost__mutmut_7: survived
shop.shipping.x_shipping_cost__mutmut_10: survived
shop.shipping.x_shipping_cost__mutmut_12: survived
Szczegóły pokazuje mutmut show <nazwa mutanta>. Najciekawsze przypadki:
- cost = 0 if order_total >= FREE_SHIPPING_THRESHOLD else BASE_COST
+ cost = 0 if (order_total >= FREE_SHIPPING_THRESHOLD) or True else BASE_COST
Ten mutant sprawia, że dostawa jest zawsze darmowa. Przeżył, bo test ekspresu porównuje tylko, że ekspres jest droższy (10 zł > 0 zł), a żaden test nie sprawdza, że zwykła dostawa kosztuje 15 zł.
- cost = 0 if order_total >= FREE_SHIPPING_THRESHOLD else BASE_COST
+ cost = 0 if order_total > FREE_SHIPPING_THRESHOLD else BASE_COST
Klient z zamówieniem za dokładnie 200 zł zapłaciłby za dostawę. Test sprawdzał 500 zł, a nie samą granicę.
- if order_total < 0:
+ if order_total <= 0:
Zamówienie za 0 zł (np. w całości opłacone bonem) nagle rzuca wyjątek. Podobnie przeżył mutant < 1. Pozostałe cztery to zmiany komunikatu wyjątku, bo test sprawdzał tylko typ ValueError.
Jak poprawić testy, żeby zabiły mutanty?
Każdy przeżyty mutant mówi dokładnie, jakiego testu brakuje. Poprawione testy sprawdzają konkretne kwoty i granice:
import pytest
from shop.shipping import shipping_cost
@pytest.mark.parametrize(
("order_total", "express", "expected"),
[
(0, False, 15), # zamówienie za 0 zł nie jest błędem
(0.5, False, 15), # poniżej 1 zł też nie
(199.99, False, 15), # tuż pod progiem
(200, False, 0), # dokładnie próg: darmowa dostawa
(100, True, 25), # ekspres doliczany do zwykłej dostawy
(200, True, 10), # ekspres przy darmowej dostawie
],
)
def test_shipping_cost(order_total, express, expected):
assert shipping_cost(order_total, express=express) == expected
def test_negative_total_raises():
with pytest.raises(ValueError, match="^Kwota zamówienia nie może być ujemna$"):
shipping_cost(-1)
Kolejne uruchomienie mutmut: 13 zabitych, 1 przeżył. Tym razem był to mutant, którego wcześniej nie zauważyliśmy:
-def shipping_cost(order_total: float, express: bool = False) -> float:
+def shipping_cost(order_total: float, express: bool = True) -> float:
Każdy nowy test podawał express jawnie, więc nikt nie sprawdzał wartości domyślnej. Wystarczył jeden test:
def test_express_is_off_by_default():
assert shipping_cost(100) == 15
Wynik: 14 z 14 mutantów zabitych, a pokrycie kodu jest takie samo jak na początku, czyli 100%. Różnica między pierwszymi a ostatnimi testami jest widoczna tylko w testach mutacyjnych.
Testy oparte na konkretnych przykładach i wartościach granicznych to też punkt wyjścia w TDD i BDD z pytestem.
Co zrobić z mutantami, których nie warto zabijać?
Nie każdy przeżyty mutant oznacza słaby test. Typowe przypadki:
- Napisy w logach i komunikatach. Jeśli nie chcesz testować dokładnej treści logów, wyłącz te mutacje w konfiguracji, np.
do_not_mutate_patterns = ['logger\.\w+']. - Pojedyncze linie. Komentarz
# pragma: no mutatewyłącza mutacje w jednej linii, a# pragma: no mutate blockw całym bloku. - Mutanty równoważne. Czasem zmiana nie zmienia zachowania programu, np.
breakzamienione nacontinuena końcu pętli. Takiego mutanta nie da się zabić żadnym testem i wtedy go oznaczasz, a nie dopisujesz sztuczny test.
Komunikatów wyjątków w naszym przykładzie nie wyłączaliśmy, bo komunikat trafia do użytkownika i warto go sprawdzić.
Jak poprosić AI o testy, które przetrwają testy mutacyjne?
Najlepiej działa pętla: AI pisze testy, mutmut pokazuje przeżyte mutanty, a Ty wklejasz konkretny mutant do asystenta. Szablon polecenia:
Oto funkcja i jej testy. Narzędzie mutmut pokazało, że przeżył ten mutant:
<wklej wynik mutmut show>
Napisz jeden test pytest, który nie przejdzie dla tego mutanta, a przejdzie dla oryginalnego kodu.
Sprawdzaj konkretne wartości, nie typy ani porównania względne.
Nie zmieniaj kodu funkcji.
Ostatnie zdanie jest ważne: bez niego model potrafi „naprawić” sytuację, zmieniając kod pod test. Więcej o formułowaniu takich poleceń piszemy w artykule o tym, jak pisać prompty do kodu.
To podejście stosują też duże firmy. Meta opisała system ACH, w którym model językowy generuje mutanty, a potem testy, które je zabijają. W badaniu na 10 795 klasach aplikacji na Androida inżynierowie zaakceptowali 73% wygenerowanych testów (Foster i in., „Mutation-Guided LLM-based Test Generation at Meta”, arXiv, styczeń 2025).
Czym różnią się testy mutacyjne od testów opartych na właściwościach?
To dwa różne narzędzia, które się uzupełniają:
| Testy mutacyjne | Testy oparte na właściwościach (property-based testing) | |
|---|---|---|
| Co zmieniają | Twój kod (wprowadzają błędy) | dane wejściowe (generują setki przypadków) |
| Na jakie pytanie odpowiadają | czy moje testy wyłapią błąd? | czy kod działa dla nietypowych danych? |
| Narzędzie w Pythonie | mutmut | Hypothesis |
| Wynik | lista przeżytych mutantów | konkretny przypadek, który psuje kod |
Testy oparte na właściwościach często same zabijają dużo mutantów, bo sprawdzają wiele wartości, w tym graniczne.
Kiedy testy mutacyjne się nie opłacają?
Testy mutacyjne uruchamiają cały zestaw testów wiele razy, więc są wolne. W naszym przykładzie 14 mutantów to ułamek sekundy, ale w dużym projekcie mogą to być tysiące mutantów i godziny. Praktyczne zasady:
- uruchamiaj je na modułach z logiką biznesową (ceny, uprawnienia, obliczenia), a nie na całym repozytorium,
- w CI puszczaj je raz na noc albo przed wydaniem, a nie przy każdym commicie,
mutmut print-time-estimatespokaże, które mutanty zajmują najwięcej czasu,- nie celuj w 100% na siłę: wynik mutacyjny to wskazówka, gdzie brakuje testów, a nie kolejna metryka do raportu.
Co sprawdzić, zanim zaakceptujesz testy od AI?
Krótka lista, którą możesz przejść przy każdym zestawie testów od asystenta:
- Konkretne wartości. Każda asercja porównuje wynik z konkretną wartością, a nie typ albo „większe niż”.
- Granice z kodu. Dla każdego
<,<=,>=i progu w kodzie jest test dokładnie na granicy i tuż obok niej. - Wartości domyślne. Przynajmniej jeden test wywołuje funkcję bez opcjonalnych argumentów.
- Komunikaty wyjątków.
pytest.raisesmamatch=, jeśli komunikat trafia do użytkownika. - Testy mutacyjne na zmienionym module.
mutmut runprzed merge'em i przejrzenie przeżytych mutantów.
Jeśli chcesz przećwiczyć pisanie testów w Pythonie z feedbackiem od mentora, zajrzyj do modułu Python: Testowanie.


