0 dní v řadě · 0 bodů

Profesionální vývoj · 30 min

Testování: unittest a pytest

Napíšeš testy, které opravdu chytají chyby. Hranice, výjimky, příprava dat, unittest, pytest a proč 100% pokrytí nic neslibuje.

Hloubka
Úkoly
Lidsky řečeno

Pilot má za sebou tisíce letů, a stejně před každým startem projde kontrolní seznam. Ne proto, že by neuměl létat, ale protože unavený člověk občas zapomene. Testy jsou takový seznam pro program. Rozdíl je v tom, že ho za tebe projde počítač, za pár sekund a po každé změně.

Test je program, který kontroluje program

Napsal jsi funkci a zkusil ji. Fungovala. O měsíc později ji upravíš kvůli něčemu jinému a nevíš, jestli pořád dělá to, co dřív. Ruční zkoušení se po desáté nikomu nechce.

Automatický test je kousek kódu, který funkci zavolá a porovná výsledek s očekáváním. Má skoro vždy tři kroky: připrav, proveď, ověř. Anglicky se tomu říká Arrange, Act, Assert.

def cena_po_sleve(cena, procenta):
    return round(cena * (1 - procenta / 100), 2)

# připrav
cena = 200
# proveď
vysledek = cena_po_sleve(cena, 10)
# ověř
assert vysledek == 180, f"čekal jsem 180, vyšlo {vysledek}"

print("Test prošel.")
Výstup
Test prošel.

Příkaz assert nedělá nic, když podmínka platí. Když neplatí, vyvolá AssertionError. Stačí jedno špatné znaménko a test se ozve:

def cena_po_sleve(cena, procenta):
    return round(cena * (1 + procenta / 100), 2)  # omylem plus

vysledek = cena_po_sleve(200, 10)
assert vysledek == 180, f"čekal jsem 180, vyšlo {vysledek}"
print("Tohle se nevypíše.")
Výstup

Testy mají ještě jeden přínos, který není hned vidět. Když víš, že tě pohlídají, nebojíš se starý kód upravovat. Přepsání kódu beze změny chování se říká refaktoring a bez testů je to chůze po tmě.

unittest: testy ve třídě

Holé assert za sebou brzy nestačí. První chyba by zastavila všechno a nedozvěděl by ses o dalších. Standardní knihovna proto má modul unittest.

Testy se píšou jako metody třídy odvozené od unittest.TestCase. Metoda musí začínat slovem test, jinak se nespustí. Každá běží zvlášť, takže chyba v jedné nezastaví ostatní.

import unittest

def cena_po_sleve(cena, procenta):
    if not 0 <= procenta <= 100:
        raise ValueError("sleva musí být 0 až 100 %")
    return round(cena * (1 - procenta / 100), 2)

class TestSleva(unittest.TestCase):
    def test_bezna_sleva(self):
        self.assertEqual(cena_po_sleve(200, 10), 180)

    def test_nulova_sleva_cenu_nemeni(self):
        self.assertEqual(cena_po_sleve(99.9, 0), 99.9)

    def test_plna_sleva_je_zadarmo(self):
        self.assertEqual(cena_po_sleve(200, 100), 0)

sada = unittest.defaultTestLoader.loadTestsFromTestCase(TestSleva)
vysledek = unittest.TestResult()
sada.run(vysledek)

print("spuštěno:", vysledek.testsRun)
print("vše v pořádku:", vysledek.wasSuccessful())
Výstup
spuštěno: 3
vše v pořádku: True

Spodní část ukázky, od řádku sada = ..., je tu kvůli spuštění v prohlížeči. Ve skutečném projektu máš testy v souboru tests/test_sleva.py a pouštíš je z terminálu:

bash
python -m unittest discover -s tests        # najde a spustí všechny testy
python -m unittest discover -s tests -v     # vypíše každý test zvlášť
python -m unittest tests.test_sleva         # jen jeden soubor
python -m unittest discover -s tests -k sleva   # jen testy se „sleva“ v názvu

Teď test, který selže. Pomocná funkce spust vypíše jen podstatnou část hlášení.

import unittest

def spust(trida):
    vysledek = unittest.TestResult()
    unittest.defaultTestLoader.loadTestsFromTestCase(trida).run(vysledek)
    print(f"spuštěno {vysledek.testsRun}, selhalo {len(vysledek.failures)}, chyby {len(vysledek.errors)}")
    for test, stopa in vysledek.failures + vysledek.errors:
        print("-", test.id().removeprefix("__main__."), "=>", stopa.strip().splitlines()[-1])

def prumer(cisla):
    return sum(cisla) / len(cisla)

class TestPrumer(unittest.TestCase):
    def test_dve_cisla(self):
        self.assertEqual(prumer([2, 4]), 3)

    def test_spatne_ocekavani(self):
        self.assertEqual(prumer([1, 2]), 2)

    def test_prazdny_seznam_vrati_nulu(self):
        self.assertEqual(prumer([]), 0)

spust(TestPrumer)
Výstup
spuštěno 3, selhalo 1, chyby 1
- TestPrumer.test_spatne_ocekavani => AssertionError: 1.5 != 2
- TestPrumer.test_prazdny_seznam_vrati_nulu => ZeroDivisionError: division by zero

Všimni si dvou různých druhů neúspěchu. Failure znamená, že ověření nesedělo. Error znamená, že test spadl na neočekávané výjimce, tady ZeroDivisionError. A pozor: selhaný test neříká, kdo má pravdu. V test_spatne_ocekavani je chybně test, protože průměr 1 a 2 je 1.5.

Nejpoužívanější ověřovací metody:

MetodaOvěří
assertEqual(a, b)a == b
assertTrue(x), assertFalse(x)pravdivost x
assertIs(a, b), assertIsNone(x)stejný objekt, None
assertIn(a, b)a in b
assertAlmostEqual(a, b)rovnost na 7 desetinných míst
assertRaises(Chyba)blok vyvolá výjimku
assertCountEqual(a, b)stejné prvky v libovolném pořadí
Úkol

Testy, které něco chytí

Doprava stojí 99 Kč, od 1000 Kč je zdarma a záporná cena vyvolá ValueError. Doplň třídu TestDoprava. Kontrola tvé testy pustí proti správné funkci, kde musí projít, a proti třem rozbitým verzím, kde musí selhat.

import unittest

def doprava(cena):
    if cena < 0:
        raise ValueError("cena nesmí být záporná")
    return 0 if cena >= 1000 else 99

class TestDoprava(unittest.TestCase):
    def test_levny_nakup(self):
        self.assertEqual(doprava(100), 99)

    # doplň další testy
Výstup

Jaké případy vybrat

Všechna čísla otestovat nejde. Vstupy si proto rozděl do skupin, ve kterých se funkce chová stejně, a z každé vezmi jednoho zástupce. Těm skupinám se říká třídy ekvivalence. Přidej hranice, protože tam vznikají chyby nejčastěji. Hodně z nich je o jedničku vedle nebo < místo <=.

Pro funkci, která ověřuje věk 18 až 65:

text
         neplatné      │       platné       │     neplatné
  ... 16  17           │ 18  19 ... 64  65  │ 66  67 ...
              ▲          ▲              ▲     ▲
              └ hranice ─┘              └ hranice ┘

Stačí pět až šest hodnot: 17, 18, 40, 65, 66 a něco nesmyslného. Podobné případy se hodí zapsat jako tabulku. Metoda subTest zajistí, že selhání jednoho řádku nezastaví ostatní.

import unittest

def spust(trida):
    vysledek = unittest.TestResult()
    unittest.defaultTestLoader.loadTestsFromTestCase(trida).run(vysledek)
    print(f"spuštěno {vysledek.testsRun}, selhalo {len(vysledek.failures)}")
    for test, stopa in vysledek.failures:
        print("-", test.id().removeprefix("__main__."), "=>", stopa.strip().splitlines()[-1])

def muze_pracovat(vek):
    return 18 < vek <= 65  # chyba: 18 má být povoleno

class TestVek(unittest.TestCase):
    def test_hranice(self):
        tabulka = [(17, False), (18, True), (40, True), (65, True), (66, False)]
        for vek, ocekavano in tabulka:
            with self.subTest(vek=vek):
                self.assertEqual(muze_pracovat(vek), ocekavano)

    def test_soucet_desetinnych_cisel(self):
        self.assertAlmostEqual(0.1 + 0.2, 0.3)

    def test_chybny_vstup(self):
        with self.assertRaisesRegex(ValueError, "invalid literal"):
            int("osmnáct")

spust(TestVek)
Výstup
spuštěno 3, selhalo 1
- TestVek.test_hranice (vek=18) => AssertionError: False != True

Testy mají chránit chování, ne podobu kódu. Dobrý test přežije přejmenování pomocné funkce nebo změnu vnitřního algoritmu. Spadne jen tehdy, když program začne dávat jiné výsledky.

Kvíz

Funkce dává slevu pro objednávky od 500 Kč výš. Která trojice vstupů je nejužitečnější?

Příprava a úklid

Testy často potřebují stejná výchozí data. Metoda setUp se spustí před každým testem, takže každý začíná s čistým stolem. To je základní pravidlo: testy na sobě nesmí záviset. Když jeden něco změní a druhý s tím počítá, začnou selhávat podle pořadí spuštění.

Tady má každý test vlastní databázi v paměti. Modul sqlite3 je součástí Pythonu a adresa :memory: vytvoří databázi, která zmizí se zavřením spojení. SQL podrobně probere lekce SQL a sqlite3.

import sqlite3
import unittest

def pridej_zakaznika(db, email):
    with db:
        db.execute("INSERT INTO zakaznik (email) VALUES (?)", (email,))

def pocet_zakazniku(db):
    return db.execute("SELECT COUNT(*) FROM zakaznik").fetchone()[0]

class TestZakaznici(unittest.TestCase):
    def setUp(self):
        self.db = sqlite3.connect(":memory:")
        self.addCleanup(self.db.close)
        self.db.execute("CREATE TABLE zakaznik (email TEXT UNIQUE NOT NULL)")

    def test_pridani(self):
        pridej_zakaznika(self.db, "[email protected]")
        self.assertEqual(pocet_zakazniku(self.db), 1)

    def test_kazdy_test_zacina_s_prazdnou_tabulkou(self):
        self.assertEqual(pocet_zakazniku(self.db), 0)

    def test_duplicitni_email_neprojde(self):
        pridej_zakaznika(self.db, "[email protected]")
        with self.assertRaises(sqlite3.IntegrityError):
            pridej_zakaznika(self.db, "[email protected]")
        self.assertEqual(pocet_zakazniku(self.db), 1)

vysledek = unittest.TestResult()
unittest.defaultTestLoader.loadTestsFromTestCase(TestZakaznici).run(vysledek)
print(vysledek.testsRun, "testy, v pořádku:", vysledek.wasSuccessful())
Výstup
3 testy, v pořádku: True

addCleanup si zapamatuje úklid a provede ho po testu, i když test selže. K dispozici je také tearDown, ale addCleanup je bezpečnější, jak ukáže blok níže.

Úkol

Testy, které si překážejí

Testy sdílejí slovník sklad, takže druhý selže kvůli prvnímu. Přesuň vytvoření skladu do setUp a v testech používej self.sklad. Názvy testů neměň. Kontrola je pustí v obou pořadích.

import unittest

sklad = {"kava": 10}

class TestSklad(unittest.TestCase):
    def test_a_vydej(self):
        sklad["kava"] -= 3
        self.assertEqual(sklad["kava"], 7)

    def test_b_pocatecni_stav(self):
        self.assertEqual(sklad["kava"], 10)
Výstup
Úkol

Nejdřív test, potom kód

Testy už existují a popisují, co má funkce normalizuj_psc dělat. Oprav funkci, aby prošly. Tomuhle postupu se říká TDD, vývoj řízený testy: červený test, nejjednodušší kód, úklid.

import unittest

def normalizuj_psc(text):
    return text.strip()

class TestPsc(unittest.TestCase):
    def test_doplni_mezeru(self):
        self.assertEqual(normalizuj_psc("11000"), "110 00")

    def test_necha_spravny_tvar(self):
        self.assertEqual(normalizuj_psc("110 00"), "110 00")

    def test_odstrani_okraje(self):
        self.assertEqual(normalizuj_psc("  602 00 "), "602 00")

    def test_kratke_je_chyba(self):
        with self.assertRaises(ValueError):
            normalizuj_psc("110")

    def test_pismena_jsou_chyba(self):
        with self.assertRaises(ValueError):
            normalizuj_psc("11O00")
Výstup
Pod kapotou · jak unittest opravdu běží

Pro každou testovací metodu vzniká nová instance třídy, proto atributy z setUp mezi testy nepřetečou. Atributy třídy ale sdílené jsou. Pořadí je abecední podle názvu metody a nemá se na něm stavět.

addCleanup má dvě výhody oproti tearDown: úklid běží i tehdy, když spadne setUp, a registruje se hned vedle vytvoření zdroje. Provádí se v opačném pořadí, než byl registrován, takže závislé zdroje se ruší správně.

import unittest

instance, sdilene = [], []

class Ukazka(unittest.TestCase):
    pocitadlo = []

    def test_a(self):
        instance.append(self)
        Ukazka.pocitadlo.append("a")

    def test_b(self):
        instance.append(self)
        sdilene.append(len(Ukazka.pocitadlo))

class SpadlySetUp(unittest.TestCase):
    def setUp(self):
        self.addCleanup(print, "cleanup 1: zavřít spojení")
        self.addCleanup(print, "cleanup 2: smazat soubor")
        raise RuntimeError("setUp spadl")

    def tearDown(self):
        print("tearDown")

    def test_x(self):
        print("test")

for trida in (Ukazka, SpadlySetUp):
    unittest.defaultTestLoader.loadTestsFromTestCase(trida).run(unittest.TestResult())

print("různých instancí:", len({id(x) for x in instance}))
print("test_b viděl v atributu třídy položek:", sdilene[0])
Výstup
cleanup 2: smazat soubor
cleanup 1: zavřít spojení
různých instancí: 2
test_b viděl v atributu třídy položek: 1

V Pythonu 3.12 zmizely staré aliasy jako assertEquals a assertRegexpMatches, takže starší testy po upgradu padají na AttributeError. Přibyl přepínač --durations N s nejpomalejšími testy a python -m unittest vrací kód 5, když nenašel žádný test. Díky tomu CI nepřehlédne překlep v cestě. Na asynchronní kód je unittest.IsolatedAsyncioTestCase.

pytest: méně psaní, víc informací

pytest je samostatný balík a v Pythonu se používá nejčastěji. Instaluje se do vývojové skupiny a nepotřebuje třídy. Test je obyčejná funkce s názvem test_... a ověřuje se běžným assert.

bash
pip install pytest
python
# tests/test_sleva.py
import pytest
from kavarna.ceny import cena_po_sleve

def test_bezna_sleva():
    assert cena_po_sleve(200, 10) == 180

def test_soucet_s_toleranci():
    assert 0.1 + 0.2 == pytest.approx(0.3)

def test_neplatna_sleva():
    with pytest.raises(ValueError, match="0 až 100"):
        cena_po_sleve(200, 150)

@pytest.mark.parametrize(
    ("procenta", "ocekavano"),
    [(0, 200), (50, 100), (100, 0)],
)
def test_tabulka(procenta, ocekavano):
    assert cena_po_sleve(200, procenta) == ocekavano

Při selhání pytest ukáže hodnoty, ze kterých výraz vznikl:

text
    def test_bezna_sleva():
>       assert cena_po_sleve(200, 10) == 181
E       assert 180.0 == 181
E        +  where 180.0 = cena_po_sleve(200, 10)

Místo setUp má fixtury. Fixtura je funkce, která něco připraví. Test si o ni řekne jménem parametru. Kód za yield je úklid. Fixtury společné více souborům patří do tests/conftest.py, který pytest načte sám.

python
# tests/conftest.py
import sqlite3
import pytest

@pytest.fixture
def db():
    spojeni = sqlite3.connect(":memory:")
    spojeni.execute("CREATE TABLE zakaznik (email TEXT UNIQUE NOT NULL)")
    yield spojeni
    spojeni.close()

# tests/test_zakaznici.py
def test_pridani(db):
    db.execute("INSERT INTO zakaznik VALUES ('[email protected]')")
    assert db.execute("SELECT COUNT(*) FROM zakaznik").fetchone()[0] == 1

# Vestavěné fixtury
def test_export(tmp_path, monkeypatch, capsys):
    monkeypatch.setenv("KAVARNA_MENA", "CZK")     # po testu se vrátí zpět
    soubor = tmp_path / "vystup.txt"              # dočasná složka pro každý test
    soubor.write_text("ok", encoding="utf-8")
    print("hotovo")
    assert capsys.readouterr().out == "hotovo\n"  # zachycený výstup

Příkazy, které budeš používat denně:

bash
pytest                    # všechny testy
pytest -q                 # stručný výpis
pytest -x                 # skončí po první chybě
pytest --lf               # jen testy, které minule selhaly
pytest -k sleva           # jen testy s tímto slovem v názvu
pytest -m "not slow"      # bez testů označených @pytest.mark.slow
pytest --durations=5      # pět nejpomalejších

Nastavení patří do pyproject.toml:

toml
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = ["--import-mode=importlib", "--strict-markers", "--strict-config"]
markers = ["slow: pomalé testy, v běžném běhu se přeskakují"]
xfail_strict = true
unittestpytest
Instalacesoučást Pythonusamostatný balík
Zápis testutřída a metodyfunkce
Ověřeníself.assertEqual(a, b)assert a == b
PřípravasetUp, addCleanupfixtury
Tabulka případůsubTestparametrize
Rozšířenímálostovky pluginů

Přechod je snadný, protože pytest umí spustit i existující testy z unittest.

Kvíz

Kdy se spustí kód za yield v běžné pytest fixtuře?

Pod kapotou · co pytest dělá s assert

Běžný assert zná jen pravdivostní hodnotu. Pytest proto testovací moduly a conftest.py při importu přepíše na úrovni AST a mezivýsledky si uloží. Pomocné moduly mimo tuto skupinu přepsané nejsou, v nich zapni přepis přes pytest.register_assert_rewrite("tests.pomocne"). Assert v produkčním kódu na vstupy nepatří, protože python -O ho odstraní.

Pár věcí z provozu velkých sad:

  • Fixtura se scope="session" šetří čas, ale sdílí stav. Drahé spuštění sdílej a izolaci zajisti transakcí vrácenou po každém testu.
  • --import-mode=importlib nemění sys.path, proto soubory testů nemusí mít unikátní názvy. Pomocné moduly pak ale nejsou importovatelné samy od sebe, patří do conftest.py nebo do balíčku.
  • pytest-xdist (-n auto) rozdělí testy do procesů a odhalí sdílené soubory a porty. pytest-randomly zamíchá pořadí a odhalí závislosti mezi testy.
  • Nestabilní test, který občas selže, je horší než žádný, protože učí lidi selhání ignorovat. Obvyklé příčiny: čas, náhoda, síť, pořadí, souběh. Opakování přes --reruns je náplast, ne oprava.
  • Hypothesis generuje vstupy podle popisu a hledá nejmenší protipříklad. Hodí se na vlastnosti typu decode(encode(x)) == x.

Pokrytí a co z něj nevyčteš

Pokrytí (coverage) říká, které řádky se během testů spustily. Nástroj coverage to změří a ukáže místa, kam žádný test nedosáhl.

bash
pip install coverage pytest-cov
pytest --cov=kavarna --cov-branch --cov-report=term-missing
text
Name                 Stmts   Miss Branch BrPart  Cover   Missing
----------------------------------------------------------------
src/kavarna/ceny.py     12      2      4      1    81%   17-18

Přepínač --cov-branch sleduje i větve, tedy jestli podmínka proběhla oběma směry. Nízké pokrytí je užitečná informace: tenhle kód nikdo nezkouší. Vysoké pokrytí ale neznamená správnost. Řádek se může spustit, aniž by někdo ověřil jeho výsledek.

Testy se obvykle skládají do pyramidy. Rychlých jednotkových je nejvíc, pomalých přes celý systém jen pár.

text
        /\          end-to-end: celá aplikace, pomalé, málo
       /  \
      /────\        integrační: kód + databáze, soubory
     /      \
    /────────\      jednotkové: funkce a třídy, rychlé, hodně
Pod kapotou · mutační testování: kdo testuje testy

Mutační testování kód záměrně rozbije a sleduje, jestli si toho testy všimnou. Přežitý mutant znamená díru v testech, i když je pokrytí stoprocentní. Nástroje jako mutmut nebo cosmic-ray to dělají ve velkém. Princip se vejde do pár řádků nad modulem ast:

import ast

ZDROJ = """
def doprava(cena):
    return 0 if cena >= 1000 else 99
"""

class ZmenaHranice(ast.NodeTransformer):
    def visit_Compare(self, uzel):
        uzel.ops = [ast.Gt() if isinstance(op, ast.GtE) else op for op in uzel.ops]
        return uzel

def nacti(strom):
    prostor = {}
    exec(compile(strom, "<mutant>", "exec"), prostor)
    return prostor["doprava"]

def slabe_testy(f):
    return f(500) == 99 and f(2000) == 0

def silne_testy(f):
    return slabe_testy(f) and f(1000) == 0

puvodni = nacti(ast.parse(ZDROJ))
mutant = nacti(ZmenaHranice().visit(ast.parse(ZDROJ)))

for nazev, testy in [("slabé", slabe_testy), ("silné", silne_testy)]:
    print(f"{nazev}: původní prošel={testy(puvodni)}, mutant prošel={testy(mutant)}")
Výstup
slabé: původní prošel=True, mutant prošel=True
silné: původní prošel=True, mutant prošel=False

Slabé testy spustí každý řádek funkce, pokrytí je tedy plné, a přesto mutanta pustí dál. Mutační běh je drahý, protože opakuje testy pro každou změnu. Vyplatí se zaměřit ho na kritické moduly nebo jen na změněné řádky.

Na Pythonu 3.12 může coverage měřit přes sys.monitoring (PEP 669) s proměnnou COVERAGE_CORE=sysmon, což výrazně snižuje režii oproti sys.settrace. Větvové pokrytí tímto způsobem ale podporuje až novější Python.

Vyzkoušej si: Které testy chybu chytí

Zapínej chyby v malé funkci a sleduj, které z testů je odhalí a které ne.