Lidsky řečeno
Piloti se neučí nouzové přistání ve skutečném letadle s cestujícími. Sedí v simulátoru, který se chová jako letadlo, ale nic v něm nemůže spadnout. Testy potřebují totéž. Nechceš při každém spuštění poslat zákazníkům e-mail, strhnout peníze z karty nebo čekat do půlnoci, až se změní datum.
Proč se některý kód testuje špatně
Podívej se na tuhle funkci. Má dva řádky a test na ni se napsat nedá.
from datetime import datetime
def pozdrav():
hodina = datetime.now().hour
return "Dobré ráno" if hodina < 12 else "Dobrý den"
print(pozdrav())
Výsledek závisí na tom, kolik je hodin. Test, který čeká „Dobré ráno“, odpoledne selže. Funkce si svůj vstup tajně bere z okolního světa.
Stejný problém mají další věci mimo program: síť, databáze, soubory, náhoda, proměnné prostředí, odesílání e-mailů. Říká se jim vedlejší efekty a závislosti. Jsou pomalé, nespolehlivé nebo nevratné.
Řešení je překvapivě prosté. Předej tu věc jako parametr.
from datetime import datetime
def pozdrav(ted):
return "Dobré ráno" if ted.hour < 12 else "Dobrý den"
assert pozdrav(datetime(2026, 3, 1, 8, 0)) == "Dobré ráno"
assert pozdrav(datetime(2026, 3, 1, 11, 59)) == "Dobré ráno"
assert pozdrav(datetime(2026, 3, 1, 12, 0)) == "Dobrý den"
print("Testy prošly a běží kdykoli.")
Testy prošly a běží kdykoli.
Skutečný čas teď dodá až volající: pozdrav(datetime.now()). Funkce se stala čistou. Se stejným vstupem vrátí vždy stejný výsledek a nic kolem sebe nemění.
Vytáhni čas ven
Přepiš je_otevreno tak, aby přijímala parametr ted. Otevřeno je od pondělí do pátku (weekday() vrací 0 až 4) od 8:00 včetně do 18:00. Přesně v 18:00 už je zavřeno.
from datetime import datetime
def je_otevreno():
ted = datetime.now()
return ted.weekday() < 5 and 8 <= ted.hour <= 18
Závislosti předávej zvenku
Stejný princip funguje ve větším. Program rozděl na dvě části:
- Jádro obsahuje rozhodování. Jsou to čisté funkce, které dostanou data a vrátí data.
- Slupka obstarává kontakt se světem: načte data, zavolá jádro a výsledek někam pošle. Je tenká a skoro bez podmínek.
Anglicky se tomu říká functional core, imperative shell. Předávání závislostí zvenku se jmenuje dependency injection. Zní to učeně, ale je to jen parametr.
from dataclasses import dataclass
from datetime import date, timedelta
from typing import Protocol
@dataclass(frozen=True)
class Faktura:
cislo: str
email: str
splatnost: date
zaplaceno: bool = False
# Jádro: čisté rozhodnutí, stačí mu data.
def po_splatnosti(faktury, dnes, tolerance_dni=3):
hranice = dnes - timedelta(days=tolerance_dni)
return [f for f in faktury if not f.zaplaceno and f.splatnost < hranice]
# Popis toho, co slupka potřebuje.
class Posta(Protocol):
def posli(self, komu: str, text: str) -> None: ...
# Slupka: propojí jádro se světem.
def rozesli_upominky(faktury, posta: Posta, dnes):
vybrane = po_splatnosti(faktury, dnes)
for f in vybrane:
posta.posli(f.email, f"Faktura {f.cislo} je po splatnosti.")
return len(vybrane)
# Falešná pošta pro test: nic neposílá, jen si pamatuje.
class FalesnaPosta:
def __init__(self):
self.odeslano = []
def posli(self, komu, text):
self.odeslano.append((komu, text))
dnes = date(2026, 3, 10)
faktury = [
Faktura("F1", "[email protected]", date(2026, 3, 1)),
Faktura("F2", "[email protected]", date(2026, 3, 1), zaplaceno=True),
Faktura("F3", "[email protected]", date(2026, 3, 8)),
]
posta = FalesnaPosta()
print("odesláno:", rozesli_upominky(faktury, posta, dnes))
print(posta.odeslano)
odesláno: 1
[('[email protected]', 'Faktura F1 je po splatnosti.')]Test proběhne okamžitě a nikdo nedostane e-mail. V produkci předáš skutečnou třídu se stejnou metodou posli. Funkce rozesli_upominky rozdíl nepozná. Protocol tu jen popisuje očekávaný tvar, víc v lekci ABC a Protocol.
Testovací náhradám se souhrnně říká dvojníci (test doubles), podle kaskadérů ve filmu. Mají několik druhů:
| Druh | Co dělá | Příklad |
|---|---|---|
| Dummy | jen vyplní parametr, nikdo ho nepoužije | None místo loggeru |
| Stub | vrací připravenou odpověď | kurz je vždy 25 |
| Fake | jednoduchá funkční náhrada | databáze ve slovníku |
| Spy | zaznamenává, jak byl volán | FalesnaPosta výše |
| Mock | navíc ověřuje očekávaná volání | assert_called_once_with |
Co je na funkci rozesli_upominky hlavní přínos parametru posta?
Protocol ani anotace se za běhu nekontrolují. Podstatné je, že volající rozhoduje, jaký objekt funkce dostane.
unittest.mock: dvojník na počkání
Psát třídu pro každou maličkost by zdržovalo. Modul unittest.mock nabízí objekt Mock, který přijme jakékoli volání a pamatuje si je.
from unittest.mock import Mock, call
kurzy = Mock()
kurzy.aktualni.return_value = 25.0 # stub: co má metoda vrátit
def na_koruny(eura, kurzy):
return eura * kurzy.aktualni("EUR")
print(na_koruny(4, kurzy))
kurzy.aktualni.assert_called_once_with("EUR") # ověření volání
print("počet volání:", kurzy.aktualni.call_count)
# side_effect: postupné odpovědi, výjimka nebo vlastní funkce
sluzba = Mock()
sluzba.nacti.side_effect = [ConnectionError("výpadek"), {"stav": "ok"}]
try:
sluzba.nacti("/stav")
except ConnectionError as chyba:
print("první pokus:", chyba)
print("druhý pokus:", sluzba.nacti("/stav"))
print(sluzba.nacti.call_args_list == [call("/stav"), call("/stav")])
100.0
počet volání: 1
první pokus: výpadek
druhý pokus: {'stav': 'ok'}
TrueOchota přijmout cokoli je ale i slabina. Holý Mock spolkne překlep v názvu metody i špatný počet argumentů. Test projde a v produkci to spadne. Proto mu dej vzor přes create_autospec. Mock pak zná skutečné metody a jejich parametry.
from unittest.mock import Mock, create_autospec
class Posta:
def posli(self, komu, text):
raise RuntimeError("v testu se nesmí volat")
holy = Mock()
holy.poslat("[email protected]") # překlep i chybějící argument
print("holý Mock: žádná chyba")
presny = create_autospec(Posta, instance=True)
try:
presny.poslat("[email protected]")
except AttributeError as chyba:
print("špatná metoda:", chyba)
try:
presny.posli("[email protected]")
except TypeError as chyba:
print("špatné argumenty:", chyba)
presny.posli("[email protected]", "Ahoj")
presny.posli.assert_called_once_with("[email protected]", text="Ahoj")
print("správné volání prošlo")
holý Mock: žádná chyba špatná metoda: Mock object has no attribute 'poslat' špatné argumenty: missing a required argument: 'text' správné volání prošlo
Opakování po výpadku
Napiš zkus_znovu(akce, pokusy=3, cekej=time.sleep). Zavolá akce() a vrátí její výsledek. Při ConnectionError počká a zkusí to znovu. Před druhým pokusem čeká 1 sekundu, před třetím 2, dál se čas zdvojnásobuje. Po posledním neúspěšném pokusu už nečeká a výjimku nechá propadnout.
import time
def zkus_znovu(akce, pokusy=3, cekej=time.sleep):
return akce()
Test s mockem
Doplň TestRegistrace. Použij mocky místo repo a mailer. Kontrola spustí testy proti správné funkci a pak proti třem rozbitým: neuloží zákazníka, pošle uvítání i stávajícímu, nebo vynechá úpravu e-mailu.
import unittest
from unittest.mock import Mock
def zaregistruj(email, repo, mailer):
email = email.strip().lower()
if repo.existuje(email):
return False
repo.uloz(email)
mailer.posli(email, "Vítej!")
return True
class TestRegistrace(unittest.TestCase):
def test_novy_zakaznik(self):
repo = Mock()
repo.existuje.return_value = False
self.assertTrue(zaregistruj("[email protected]", repo, Mock()))
patch: výměna tam, kde parametr nemáš
Někdy závislost předat nejde, třeba ve starém kódu nebo u funkce třetí strany. Nástroj patch dočasně nahradí jméno v modulu a po skončení bloku ho vrátí.
Jedno pravidlo způsobuje většinu potíží: patchuj tam, kde se jméno hledá, ne tam, kde vzniklo. Zápis from cenik import zakladni vytvoří v importujícím modulu vlastní proměnnou. Když změníš originál, ona pořád ukazuje na starou funkci.
import importlib
from pathlib import Path
from unittest.mock import patch
Path("cenik.py").write_text("def zakladni():\n return 100\n", encoding="utf-8")
Path("sluzba_a.py").write_text(
"from cenik import zakladni\n"
"def cena():\n"
" return zakladni() * 2\n",
encoding="utf-8",
)
Path("sluzba_b.py").write_text(
"import cenik\n"
"def cena():\n"
" return cenik.zakladni() * 2\n",
encoding="utf-8",
)
importlib.invalidate_caches()
sluzba_a = importlib.import_module("sluzba_a")
sluzba_b = importlib.import_module("sluzba_b")
with patch("cenik.zakladni", return_value=1):
print("from-import, patch v cenik:", sluzba_a.cena())
print("import modulu, patch v cenik:", sluzba_b.cena())
with patch("sluzba_a.zakladni", return_value=1):
print("from-import, patch v sluzba_a:", sluzba_a.cena())
print("po skončení bloku:", sluzba_a.cena())
from-import, patch v cenik: 200 import modulu, patch v cenik: 2 from-import, patch v sluzba_a: 2 po skončení bloku: 200
patch má další podoby pro běžné situace:
import os
from unittest.mock import patch
class Brana:
limit = 100
def zaplat(self, castka):
raise RuntimeError("skutečná platba")
def rezim():
return os.environ.get("KAVARNA_REZIM", "ostry")
# Nahrazení metody jedné třídy
with patch.object(Brana, "zaplat", return_value="OK-1") as zaplat:
print(Brana().zaplat(50))
zaplat.assert_called_once_with(50)
# Dočasná změna slovníku, typicky proměnných prostředí
with patch.dict(os.environ, {"KAVARNA_REZIM": "test"}):
print(rezim())
print(rezim())
# Jednoduchá hodnota místo funkce
with patch.object(Brana, "limit", 5):
print(Brana.limit)
print(Brana.limit)
OK-1 test ostry 5 100
Modul objednavky.py obsahuje from time import sleep. Co musíš v testu nahradit?
Modul si jméno sleep uložil u sebe a volá tuhle kopii odkazu. Náhrada time.sleep by ho nezasáhla. patch navíc potřebuje plnou cestu s modulem.
Kdy mock škodí
Mock ověřuje, že kód volá to, co sis myslel, že má volat. Neověřuje, že to tak funguje ve skutečnosti. Tři typické problémy:
- Testy kopírují implementaci. Přepíšeš dvě volání na jedno, chování je stejné a testy padají. Přestaneš jim věřit.
- Mock neví o realitě. Skutečná databáze odmítne duplicitu, mock vrátí, co mu řekneš. Všechno je zelené a produkce hoří.
- Nezbyl žádný skutečný kód. Test ověří jen to, co sám nastavil.
Proto platí několik praktických zásad:
- Čisté funkce testuj přímo, bez mocků.
- Mockuj jen hranice systému: e-mail, platby, cizí API, hodiny.
- Vlastní databázi radši spusť. SQLite v paměti nebo testovací PostgreSQL odhalí víc než mock.
- Ověřuj výsledek, a volání jen tam, kde je volání tím výsledkem, například odeslaný e-mail.
Falešná implementace může lhát stejně jako mock. Pojistkou je kontraktní test: jedna sada testů, kterou musí splnit skutečná i falešná verze. V ukázce se rozcházejí a sada to najde.
import sqlite3
import unittest
class PametoviZakaznici:
def __init__(self):
self.emaily = set()
def pridej(self, email):
if email in self.emaily:
raise ValueError("duplicita")
self.emaily.add(email)
def pocet(self):
return len(self.emaily)
class SqliteZakaznici:
def __init__(self):
self.db = sqlite3.connect(":memory:")
self.db.execute("CREATE TABLE z (email TEXT UNIQUE COLLATE NOCASE)")
def pridej(self, email):
try:
with self.db:
self.db.execute("INSERT INTO z VALUES (?)", (email,))
except sqlite3.IntegrityError:
raise ValueError("duplicita") from None
def pocet(self):
return self.db.execute("SELECT COUNT(*) FROM z").fetchone()[0]
class Kontrakt:
trida = None
def setUp(self):
self.repo = self.trida()
def test_pridani(self):
self.repo.pridej("[email protected]")
self.assertEqual(self.repo.pocet(), 1)
def test_duplicita(self):
self.repo.pridej("[email protected]")
with self.assertRaises(ValueError):
self.repo.pridej("[email protected]")
def test_velikost_pismen_se_nerozlisuje(self):
self.repo.pridej("[email protected]")
with self.assertRaises(ValueError):
self.repo.pridej("[email protected]")
class TestPamet(Kontrakt, unittest.TestCase):
trida = PametoviZakaznici
class TestSqlite(Kontrakt, unittest.TestCase):
trida = SqliteZakaznici
for sada in (TestPamet, TestSqlite):
v = unittest.TestResult()
unittest.defaultTestLoader.loadTestsFromTestCase(sada).run(v)
spadle = [t.id().rsplit(".", 1)[-1] for t, _ in v.failures + v.errors]
print(f"{sada.trida.__name__}: {v.testsRun} testy, selhaly: {spadle}")
PametoviZakaznici: 3 testy, selhaly: ['test_velikost_pismen_se_nerozlisuje'] SqliteZakaznici: 3 testy, selhaly: []
Třída Kontrakt sama od TestCase nedědí, takže se nespouští. Testy získá až dvojicí potomků. Falešná verze rozlišuje velká a malá písmena a skutečná ne. Bez kontraktu by testy nad falešnou verzí potvrzovaly chování, které v produkci neexistuje.
Máš čistou funkci spocitej_dph(cena), kterou volá vytvor_fakturu. Co v testu vytvor_fakturu udělat?
Čistá funkce je rychlá a bez vedlejších efektů, není důvod ji nahrazovat. Mock by jen svázal test s vnitřním členěním kódu.
Pod kapotou · pasti v unittest.mock
Mock tvoří atributy líně přes __getattr__ a každý je další Mock. Odtud jeho ochota přijmout cokoli. MagicMock navíc předvyplní magické metody a AsyncMock vrací korutiny. patch na async def zvolí AsyncMock sám.
Největší zrada je, že mock si argumenty ukládá odkazem. Když kód seznam po volání změní, historie volání lže. A překlepy v ověřeních, které dřív tiše procházely, Python 3.12 u holého mocku odmítá.
import copy
from unittest.mock import Mock, seal
uloz = Mock()
polozky = ["káva"]
uloz(polozky)
polozky.append("dort")
print("uložený argument:", uloz.call_args.args[0])
try:
uloz.assert_called_once_with(["káva"])
except AssertionError:
print("ověření selhalo, i když se volalo se správnými daty")
# Oprava: snímek argumentů při volání
snimky = []
uloz = Mock(side_effect=lambda x: snimky.append(copy.deepcopy(x)))
polozky = ["káva"]
uloz(polozky)
polozky.append("dort")
print("snímek:", snimky[0])
# Překlep v ověření
try:
uloz.called_once_with(["káva"])
except AttributeError as chyba:
print("3.12:", chyba)
# seal: zakáže vznik nových atributů
sluzba = Mock()
sluzba.nacti.return_value = 1
seal(sluzba)
try:
sluzba.ulozit()
except AttributeError as chyba:
print("seal:", chyba)
uložený argument: ['káva', 'dort'] ověření selhalo, i když se volalo se správnými daty snímek: ['káva'] 3.12: 'called_once_with' is not a valid assertion. Use a spec for the mock if 'called_once_with' is meant to be an attribute. seal: mock.ulozit
Další poznatky z provozu:
patch("modul.Trida", autospec=True)hlídá signatury, včetněself. Bez toho refaktoring rozhraní testy nezachytí.create_autospecale kvůli introspekci něco stojí a neumí atributy, které vznikají až v__init__. Ty doplň ručně, nebo je definuj na úrovni třídy.wraps=skutecnydělá ze skutečného objektu špeha: volání projdou a jsou zaznamenaná.- Čas abstrahuj jako
Callable[[], datetime]s výchozí hodnotou, nebo použijtime-machine. Pozor na výchozí parametrted=datetime.now(), který se vyhodnotí jen jednou při definici funkce. - U vlastního HTTP klienta je užitečné testovat skutečné parsování. Knihovny
responses(prorequests) arespx(prohttpx) nahradí jen transport, takže JSON, stavové kódy a výjimky proběhnou opravdu. - Pravidlo „nemockuj, co ti nepatří“ míří na cizí API. Napiš nad ním tenký vlastní adaptér, mockuj adaptér a samotný adaptér ověř několika integračními testy.