0 dní v řadě · 0 bodů

Profesionální vývoj · 30 min

Mocky a testovatelný návrh

Oddělíš logiku od času, sítě a databáze. Naučíš se falešné objekty, unittest.mock, správné patchování a poznáš, kdy mock lže.

Hloubka
Úkoly
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ýstup

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.")
Výstup
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í.

Úkol

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
Výstup

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)
Výstup
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ů:

DruhCo děláPříklad
Dummyjen vyplní parametr, nikdo ho nepoužijeNone místo loggeru
Stubvrací připravenou odpověďkurz je vždy 25
Fakejednoduchá funkční náhradadatabáze ve slovníku
Spyzaznamenává, jak byl volánFalesnaPosta výše
Mocknavíc ověřuje očekávaná voláníassert_called_once_with
Kvíz

Co je na funkci rozesli_upominky hlavní přínos parametru posta?

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")])
Výstup
100.0
počet volání: 1
první pokus: výpadek
druhý pokus: {'stav': 'ok'}
True

Ochota 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")
Výstup
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
Úkol

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()
Výstup
Úkol

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()))
Výstup

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())
Výstup
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)
Výstup
OK-1
test
ostry
5
100
Kvíz

Modul objednavky.py obsahuje from time import sleep. Co musíš v testu nahradit?

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}")
Výstup
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.

Kvíz

Máš čistou funkci spocitej_dph(cena), kterou volá vytvor_fakturu. Co v testu vytvor_fakturu udělat?

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)
Výstup
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_autospec ale 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=skutecny dělá ze skutečného objektu špeha: volání projdou a jsou zaznamenaná.
  • Čas abstrahuj jako Callable[[], datetime] s výchozí hodnotou, nebo použij time-machine. Pozor na výchozí parametr ted=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 (pro requests) a respx (pro httpx) 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.