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.")
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.")
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())
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:
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ázvuTeď 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)
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:
| Metoda | Ověří |
|---|---|
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í |
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
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:
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)
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.
Funkce dává slevu pro objednávky od 500 Kč výš. Která trojice vstupů je nejužitečnější?
Chování se mění právě u 500. Hodnoty daleko od hranice by chybu > místo >= neodhalily.
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())
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.
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)
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")
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])
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.
pip install pytest# 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) == ocekavanoPři selhání pytest ukáže hodnoty, ze kterých výraz vznikl:
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.
# 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ýstupPříkazy, které budeš používat denně:
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šíchNastavení patří do pyproject.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| unittest | pytest | |
|---|---|---|
| Instalace | součást Pythonu | samostatný balík |
| Zápis testu | třída a metody | funkce |
| Ověření | self.assertEqual(a, b) | assert a == b |
| Příprava | setUp, addCleanup | fixtury |
| Tabulka případů | subTest | parametrize |
| Rozšíření | málo | stovky pluginů |
Přechod je snadný, protože pytest umí spustit i existující testy z unittest.
Kdy se spustí kód za yield v běžné pytest fixtuře?
Co je před yield, je příprava. Co je za ním, je úklid, který proběhne i po selhání testu. Výjimkou je pád ještě před yield.
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=importlibneměnísys.path, proto soubory testů nemusí mít unikátní názvy. Pomocné moduly pak ale nejsou importovatelné samy od sebe, patří doconftest.pynebo do balíčku.pytest-xdist(-n auto) rozdělí testy do procesů a odhalí sdílené soubory a porty.pytest-randomlyzamí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
--rerunsje náplast, ne oprava. Hypothesisgeneruje vstupy podle popisu a hledá nejmenší protipříklad. Hodí se na vlastnosti typudecode(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.
pip install coverage pytest-cov
pytest --cov=kavarna --cov-branch --cov-report=term-missingName Stmts Miss Branch BrPart Cover Missing
----------------------------------------------------------------
src/kavarna/ceny.py 12 2 4 1 81% 17-18Př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.
/\ 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)}")
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.