Testy jednostkowe pisane przez AI: jak sprawdzić je testami mutacyjnymi

Piotr Dul

17-11-2026

AI pisze testy, które przechodzą i dają 100% pokrycia, a mimo to przepuszczają błędy. Pokazujemy na przykładzie w Pythonie, jak mutmut wyłapuje takie testy i jak je poprawić.

Testy jednostkowe pisane przez AI: jak sprawdzić je testami mutacyjnymi
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ściePrzykładCzego nie wyłapie
Sprawdzanie typu zamiast wartościassert isinstance(result, float)złej kwoty, złego wzoru
Porównanie względneassert a > btego, że obie wartości są złe
Tylko „szczęśliwa ścieżka”jeden test dla typowych danychbłędów na granicach i w rzadkich gałęziach
Brak wartości granicznychtest dla 500, nie dla 200>= zamienionego na >
Sam fakt wyjątkupytest.raises(ValueError) bez komunikaturzucenia wyjątku z innego powodu
Mockowanie wszystkiegomock zwraca to, co test sprawdzaniczego, 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:

MutacjaOryginałMutant
Operator porównaniaif total < 0:if total <= 0:
Stała liczbowaif total < 0:if total < 1:
Warunek logicznyif a >= bif (a >= b) or True
Wartość domyślnaexpress=Falseexpress=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_mutate nazywa się source_paths, a tests_dir zastąpiło pytest_add_cli_args_test_selection. Stare nazwy działają, ale wypisują ostrzeżenie. Jeśli mutmut nie może znaleźć kodu, zacznij od sprawdzenia source_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 katalogu mutants/. Bez testpaths = ["tests"] zwykłe pytest po uruchomieniu mutmut kończy się błędem import file mismatch, bo widzi dwa pliki test_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 mutate wyłącza mutacje w jednej linii, a # pragma: no mutate block w całym bloku.
  • Mutanty równoważne. Czasem zmiana nie zmienia zachowania programu, np. break zamienione na continue na 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 mutacyjneTesty 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 PythoniemutmutHypothesis
Wyniklista przeżytych mutantówkonkretny 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-estimates pokaż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:

  1. Konkretne wartości. Każda asercja porównuje wynik z konkretną wartością, a nie typ albo „większe niż”.
  2. Granice z kodu. Dla każdego <, <=, >= i progu w kodzie jest test dokładnie na granicy i tuż obok niej.
  3. Wartości domyślne. Przynajmniej jeden test wywołuje funkcję bez opcjonalnych argumentów.
  4. Komunikaty wyjątków. pytest.raises ma match=, jeśli komunikat trafia do użytkownika.
  5. Testy mutacyjne na zmienionym module. mutmut run przed 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.

Masz pytanie do artykułu? Chcesz zgłosić błąd?

Pytaj ogólnie o temat artykułu albo napisz, co poprawić. Jeśli chcesz omówić swój konkretny przypadek, umów się na rozmowę lub . Ze względów bezpieczeństwa nie przeglądamy ani nie publikujemy żadnych linków. Wiadomości z linkami nie są zapisywane. Limit: 2 pytania na godzinę.

Wyślemy na niego link do potwierdzenia pytania i odpowiedź.

Ostateczną decyzję o opublikowaniu pytania podejmuje administrator.

Konsultacja i warsztaty devmentor.pl

Masz pytania?

Partnerzy

Firmy, z którymi współpracujemy

To partnerzy odpowiedzialni za staże po naszych kursach. Organizują je dla najlepszych absolwentów.

Zobacz wszystkich partnerów →
  • VR Medical
  • Sophona
  • Robot Force