← Zpět na lekci

Testování s pytestem

assert, první testy s pytestem a jak číst test, který neprošel.

Výklad a cvičení

Výklad si můžeš přečíst přímo na webu. Příklady procházej po pořadí a kód si zkoušej ve VS Code.

Zpět na workshop

Assert

Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.

Zpět na přehled hodiny

Kontrola printem

Kino dává slevy podle věku. Děti do 15 let platí 100 Kč, senioři od 65 let 120 Kč a ostatní 180 Kč.

Spusť soubor a podívej se, jestli funkce počítá dobře.

def cena_vstupenky(vek):
    if vek < 15:
        return 100
    elif vek > 65:
        return 120
    else:
        return 180

print(cena_vstupenky(8))        # má být 100
print(cena_vstupenky(40))       # má být 180
print(cena_vstupenky(70))       # má být 120

Všechna tři čísla sedí. Je tedy funkce v pořádku?

Zkus ještě tohle:

print(cena_vstupenky(65))       # má být 120

Vyšlo 180. Senioři mají slevu od 65 let, ale funkce se ptá na vek > 65, takže šedesátipětiletá zaplatí plnou cenu. Patří tam >=.

Na tomhle příkladu jsou vidět dvě věci.

První už znáš z debuggeru v lekci 7: program, který dá dobrý výsledek pro jeden vstup, tím ještě není ověřený. Chyby se rády schovávají na hranicích – tady přesně na 65.

Druhá: kontrola printem stojí na tobě. Python vypíše číslo a ty musíš pokaždé porovnat, jestli je správně. U čtyř řádků to jde. Jenže když funkci za týden změníš, musíš znovu projít všechny výsledky a vzpomenout si, co mělo vyjít.

Lepší by bylo napsat to, co má vyjít, rovnou do kódu – a nechat porovnávání na Pythonu. Přesně to umí assert v dalším souboru.


Zpět na téma: Assert · Další: assert

Zdrojový Python soubor

assert

assert znamená „tvrdím, že“. Za něj napíšeš podmínku, stejnou jako za if. Když platí, nestane se nic. Když neplatí, program spadne s chybou AssertionError.

Spusť soubor.

def cena_vstupenky(vek):
    if vek < 15:
        return 100
    elif vek > 65:
        return 120
    else:
        return 180

assert cena_vstupenky(8) == 100
assert cena_vstupenky(40) == 180
assert cena_vstupenky(70) == 120
print("První tři kontroly prošly.")

assert cena_vstupenky(65) == 120
print("Čtvrtá kontrola prošla.")

Program spadl a v terminálu je známá chybová hláška:

Traceback (most recent call last):

  File "02_assert.py", line 24, in <module>
    assert cena_vstupenky(65) == 120
           ^^^^^^^^^^^^^^^^^^^^^^^^^
AssertionError

Čte se stejně jako hlášky z lekce 7: poslední řádek říká, co se stalo, a nad ním je řádek, na kterém to Python poznal. Tvrzení, že šedesátipětiletá zaplatí 120, neplatí.

První tři asserty prošly potichu. Nic nevypsaly, a proto je tam print, abys viděla, že na ně došlo. Čtvrtý print už se nevypsal: assert, který neplatí, program zastaví.

Co se změnilo proti printu

Správný výsledek už nemáš v hlavě ani v komentáři. Je přímo v kódu, za ==, a porovná ho Python.

Když je všechno v pořádku, je ticho. Když něco nesedí, program spadne a ukáže přesně na řádek s tvrzením, které neplatí.

Kontroly napíšeš jednou a pustíš je, kdykoli funkci změníš. Takové kontroly se jmenují testy.

Oprav to

Změň ve funkci vek > 65 na vek >= 65 a spusť soubor znovu. Teď se vypíšou oba printy a program doběhne bez chyby.

Pak zkus schválně pokazit první podmínku: vek < 15 přepiš na vek < 51. Spusť soubor. Který assert si toho všimne?


Zpět na téma: Assert · Další: Co všechno umí assert

Zdrojový Python soubor

Co všechno umí assert

Za assert můžeš napsat jakoukoli podmínku, kterou znáš z if. V testech se nejčastěji objeví těch pár tvarů níž.

Spusť soubor. Všechny asserty platí, takže se vypíše jen poslední řádek.

def pozdrav(jmeno):
    return f"Ahoj, {jmeno}!"

def je_sude(cislo):
    return cislo % 2 == 0

def kladna(cisla):
    vysledek = []
    for cislo in cisla:
        if cislo > 0:
            vysledek.append(cislo)
    return vysledek

Rovná se – nejčastější tvar. Porovnat jde číslo, text i seznam.

assert pozdrav("Jana") == "Ahoj, Jana!"
assert kladna([3, -1, 0, 5]) == [3, 5]
assert kladna([]) == []

Funkce vrací True nebo False. Stačí napsat volání, porovnání s True není potřeba. Pro False dej před volání not.

assert je_sude(4)
assert not je_sude(7)

Kus textu v delším textu, nebo položka v seznamu.

assert "Jana" in pozdrav("Jana")
assert 5 in kladna([3, -1, 0, 5])

Délka.

assert len(kladna([3, -1, 0, 5])) == 2

print("Všechno platí.")

Pozor na ==

Za assert patří dvě rovnítka, protože se porovnává. Jedno rovnítko je přiřazení do proměnné a Python ho za assertem nepustí – nahlásí SyntaxError ještě před spuštěním.

Text se porovnává přesně, i s velkými písmeny, mezerami a interpunkcí. "Ahoj, Jana" bez vykřičníku neprojde.

Kdy assert nestačí

Asserty v jednom souboru mají jednu nevýhodu. První, který neplatí, program zastaví, a o ostatních se nic nedozvíš. Kdyby v souboru byly tři chyby, uvidíš vždycky jen první.

Proto se testy píšou do zvláštních funkcí a spouští je nástroj pytest. Ten pustí všechny a na konci řekne, které prošly a které ne. O tom je další složka.


Zpět na téma: Assert · Další: Cvičení: Assert

Zdrojový Python soubor

Cvičení: Assert

Každé cvičení má vlastní soubor ve složce lekce-testovani/01_assert/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Cvičení 1

Soubor: cviceni/01_obvod_obdelniku.py

Funkce obvod spočítá obvod obdélníku ze dvou stran. Napiš pod ni tři asserty, které ověří, že počítá správně. Výsledky si spočítej sama, ne funkcí.

def obvod(a, b):
    return 2 * a + 2 * b

Sem napiš asserty:

print("Hotovo, všechny asserty platí.")
Zobrazit řešeníSkrýt řešení
def obvod(a, b):
    return 2 * a + 2 * b

assert obvod(3, 5) == 16
assert obvod(4, 4) == 16        # čtverec
assert obvod(10, 1) == 22

print("Hotovo, všechny asserty platí.")

Čísla můžou být jakákoli, hlavní je spočítat si výsledek sama. Kdybys napsala assert obvod(3, 5) == obvod(3, 5), platil by vždycky, i kdyby funkce počítala nesmysl. Test, který nemůže selhat, nic neověří.

Cvičení 2

Soubor: cviceni/02_plnoleta.py

Napiš asserty podle zadání. Jeden z nich neprojde. Najdi, proč, a oprav funkci.

Funkce je_plnoleta vrátí True, když je člověku 18 let nebo víc, jinak False.

Ověř aspoň tyhle věky: 10, 17, 18, 30.

def je_plnoleta(vek):
    return vek > 18

Sem napiš asserty:

print("Hotovo, všechny asserty platí.")
Zobrazit řešeníSkrýt řešení

Opravená funkce. Pod ní je, jak se na chybu přišlo.

def je_plnoleta(vek):
    return vek >= 18

assert not je_plnoleta(10)
assert not je_plnoleta(17)
assert je_plnoleta(18)
assert je_plnoleta(30)

print("Hotovo, všechny asserty platí.")

S původní funkcí spadne třetí assert:

assert je_plnoleta(18) AssertionError

Osmnáctiletá je podle zadání plnoletá, ale 18 > 18 neplatí. Patří tam >=.

Věky 10 a 30 by chybu nenašly. Našla ji až osmnáctka, protože leží přesně na hranici. Hranice testuj vždycky.

Cvičení 3

Soubor: cviceni/03_uklid_jmena.py

Napiš asserty podle zadání. Když některý neprojde, oprav funkci.

Funkce uklid_jmena dostane jméno tak, jak ho někdo napsal do formuláře, a vrátí ho uklizené: bez mezer na začátku a na konci, první písmeno velké a ostatní malá.

" jana " → "Jana" "PETRA" → "Petra" "eva" → "Eva"

def uklid_jmena(jmeno):
    return jmeno.capitalize().strip()

Sem napiš asserty:

print("Hotovo, všechny asserty platí.")
Zobrazit řešeníSkrýt řešení

Opravená funkce. Pod ní je, jak se na chybu přišlo.

def uklid_jmena(jmeno):
    return jmeno.strip().capitalize()

assert uklid_jmena("  jana ") == "Jana"
assert uklid_jmena("PETRA") == "Petra"
assert uklid_jmena("eva") == "Eva"

print("Hotovo, všechny asserty platí.")

S původní funkcí spadne hned první assert. Když chceš vidět, co funkce doopravdy vrátila, vypiš si to:

print(uklid_jmena("  jana "))     # jana

Mezery zmizely, ale první písmeno zůstalo malé. capitalize dá velké písmeno prvnímu znaku – a prvním znakem byla mezera. Mezery se musí uklidit dřív, než se zvětšuje: nejdřív strip, pak capitalize.

Další dva asserty by prošly i s chybou. Chybu našel jen ten vstup, který měl mezery na začátku. Zkoušej vstupy, které se od sebe liší.

Cvičení 4

Soubor: cviceni/04_drahe_polozky.py

Napiš asserty podle zadání. Mysli i na prázdný seznam.

Funkce drahe dostane seznam cen a hranici. Vrátí nový seznam jen s cenami, které jsou vyšší než hranice. Pořadí zůstane stejné.

drahe([50, 300, 120, 80], 100) → [300, 120]

def drahe(ceny, hranice):
    vysledek = []
    for cena in ceny:
        if cena > hranice:
            vysledek.append(cena)
    return vysledek

Sem napiš asserty. Ověř aspoň:

print("Hotovo, všechny asserty platí.")
Zobrazit řešeníSkrýt řešení

Funkce je správně, všechny asserty projdou.

def drahe(ceny, hranice):
    vysledek = []
    for cena in ceny:
        if cena > hranice:
            vysledek.append(cena)
    return vysledek

assert drahe([50, 300, 120, 80], 100) == [300, 120]
assert drahe([10, 20, 30], 100) == []
assert drahe([], 100) == []
assert drahe([100, 101], 100) == [101]

print("Hotovo, všechny asserty platí.")

Prázdný seznam a seznam bez drahých cen vypadají jako zbytečné případy. Funkce, které si s nimi neporadí, jsou přitom časté: třeba když počítají průměr a dělí délkou seznamu, prázdný seznam skončí dělením nulou.

Poslední assert hlídá hranici. Zadání říká „vyšší než“, takže stovka do výsledku nepatří a 101 ano.


Zpět na téma: Assert

Zdrojové soubory na GitHubu

Pytest

Procházej příklady postupně, pak si vyzkoušej cvičení. Kód z bloků si můžeš zkopírovat do Python souboru ve VS Code a spustit. Příklady na jedné stránce na sebe mohou navazovat.

Pomocné soubory, které ukázky a cvičení potřebují:

Zpět na přehled hodiny

První testy s pytestem

Tenhle soubor nespouštěj tlačítkem Run. Přečti si ho celý a podle návodu dole ho pusť přes pytest.

def cena_vstupenky(vek):
    if vek < 15:
        return 100
    elif vek >= 65:
        return 120
    else:
        return 180

def test_dite_plati_100():
    assert cena_vstupenky(8) == 100

def test_dospela_plati_180():
    assert cena_vstupenky(40) == 180

def test_seniorka_plati_120():
    assert cena_vstupenky(70) == 120

def test_seniorska_sleva_plati_od_65():
    assert cena_vstupenky(65) == 120

Asserty z minulé složky jsou teď každý ve vlastní funkci. Takové funkci se říká test. Má tři pravidla:

Za test_ napiš, co test ověřuje. Když test jednou neprojde, jméno ti řekne, co se rozbilo, dřív než otevřeš kód.

Nikde v souboru se testy nevolají. To udělá pytest: najde všechny funkce, jejichž jméno začíná test_, a postupně je zavolá.

Instalace

pytest je knihovna z PyPI, stejně jako cowsay z lekce o modulech. Nainstalovala sis ho doma podle návodu Před workshopem. Kdyby chyběl, nainstaluj ho stejně jako cowsay:

pip install pytest

Na Macu místo python piš python3 ve všech dalších příkazech, na Windows případně py.

Spuštění

  1. V levém panelu Explorer klikni pravým tlačítkem na složku 02_pytest a vyber "Open in Integrated Terminal". Otevře se terminál, který stojí v téhle složce.

  2. Napiš do něj:

python -m pytest 01_prvni_testy.py

Na konci výpisu uvidíš:

01_prvni_testy.py .... [100%]

============================ 4 passed in 0.01s ============================

Každá tečka je jeden test, který prošel. Passed znamená prošel. Když je řádek zelený, je všechno v pořádku.

Když místo toho uvidíš ERROR: file or directory not found nebo no tests ran, terminál stojí v jiné složce. Otevři ho znovu podle bodu 1.

Podrobnější výpis

Když chceš vidět jména testů, přidej na konec příkazu -v:

python -m pytest 01_prvni_testy.py -v

01_prvni_testy.py::test_dite_plati_100 PASSED [ 25%] 01_prvni_testy.py::test_dospela_plati_180 PASSED [ 50%] 01_prvni_testy.py::test_seniorka_plati_120 PASSED [ 75%] 01_prvni_testy.py::test_seniorska_sleva_plati_od_65 PASSED [100%]

Teď je vidět, proč na jménech záleží. Výpis se čte jako seznam toho, co program umí.


Zpět na téma: Pytest · Další: Když test neprojde

Zdrojový Python soubor

Když test neprojde

Ve funkci jsou dvě chyby. Spusť testy v terminálu ve složce 02_pytest:

python -m pytest 02_kdyz_test_neprojde.py

def cena_vstupenky(vek):
    if vek < 15:
        return 100
    elif vek > 65:
        return 120
    else:
        return 150

def test_dite_plati_100():
    assert cena_vstupenky(8) == 100

def test_dospela_plati_180():
    assert cena_vstupenky(40) == 180

def test_seniorka_plati_120():
    assert cena_vstupenky(70) == 120

def test_seniorska_sleva_plati_od_65():
    assert cena_vstupenky(65) == 120

Výpis je tentokrát delší. Začni odspodu, jako u chybových hlášek.

Poslední řádek: kolik prošlo

======================== 2 failed, 2 passed in 0.03s ========================

Dva testy prošly (passed), dva ne (failed). Řádek je červený.

Pytest pustil všechny čtyři testy, i když se to po cestě pokazilo. Holé asserty v minulé složce by se zastavily na první chybě a o té druhé by ses nedozvěděla.

Nad ním: které neprošly

FAILED 02_kdyz_test_neprojde.py::test_dospela_plati_180 - assert 150 == 180 FAILED 02_kdyz_test_neprojde.py::test_seniorska_sleva_plati_od_65 - assert 150 == 120

Za dvojtečkami je jméno testu, za pomlčkou tvrzení, které neplatí.

Ještě výš: podrobnosti ke každému testu

___________________________ test_dospela_plati_180 ____________________________

def test_dospela_plati_180(): > assert cena_vstupenky(40) == 180 E assert 150 == 180 E + where 150 = cena_vstupenky(40)

Řádek se šipkou > je tvrzení, které neplatí.

Řádky s E říkají proč. Pytest za tebe dosadil, co funkce doopravdy vrátila: cena_vstupenky(40) vrátila 150 a test čekal 180.

Tohle je velký rozdíl proti obyčejnému assertu. Ten by řekl jen AssertionError a co vyšlo, bys musela zjišťovat printem nebo debuggerem.

Oprav to

V obou testech vyšlo 150, a to vrací větev else. Dospělí mají platit 180. Oprav to a spusť testy znovu.

Zbude jeden červený test: šedesátipětiletá pořád platí plnou cenu. Druhou chybu už znáš. Oprav i tu.

Hotovo je, když poslední řádek říká 4 passed.

Kdo má pravdu

Když test neprojde, chyba nemusí být ve funkci. Může být i v testu: třeba sis špatně spočítala, co má vyjít.

Než něco opravíš, podívej se do zadání. Když funkce dělá, co má, a test čeká něco jiného, opravuje se test. Nikdy ale neupravuj test jen proto, aby prošel – pak už nic neověřuje.


Zpět na téma: Pytest · Další: Co testovat

Zdrojový Python soubor

Co testovat

Všechny vstupy vyzkoušet nejde. Stačí vybrat pár chytrých. Pomůžou tři otázky. Ukážeme si je na funkci, která z bodů udělá známku.

Spusť testy v terminálu ve složce 02_pytest:

python -m pytest 03_co_testovat.py -v

def znamka(body):
    if body < 0 or body > 100:
        return None
    if body >= 90:
        return 1
    elif body >= 75:
        return 2
    elif body >= 60:
        return 3
    elif body >= 45:
        return 4
    else:
        return 5

1. Obyčejný případ

Vstup, u kterého víš z hlavy, co má vyjít. Tím začni vždycky.

def test_95_bodu_je_jednicka():
    assert znamka(95) == 1

def test_50_bodu_je_ctyrka():
    assert znamka(50) == 4

2. Okraje

Hranice mezi známkami, nula, maximum. Tady se chyby schovávají nejčastěji – stačí > místo >=. Na hranici testuj přesně tu hodnotu, kde se výsledek mění.

def test_90_bodu_je_jeste_jednicka():
    assert znamka(90) == 1

def test_89_bodu_je_uz_dvojka():
    assert znamka(89) == 2

def test_0_bodu_je_petka():
    assert znamka(0) == 5

def test_100_bodu_je_jednicka():
    assert znamka(100) == 1

U seznamů a textů je okrajem prázdný seznam, prázdný text nebo jediná položka.

3. Špatný vstup

Co když přijde něco, co tam nepatří? Zadání tu říká, že funkce vrátí None. Test hlídá, že to opravdu dělá.

def test_zaporne_body_nejsou_znamka():
    assert znamka(-5) is None

def test_vic_nez_100_bodu_neni_znamka():
    assert znamka(101) is None

Na None se ptá is None, ne == None. Funguje obojí, ale is None je zvyk, který uvidíš v cizím kódu i v projektech.

Jeden test, jedna věc

Všechny asserty by se daly nacpat do jednoho testu. Kdyby ale neprošel, nevíš hned, co se rozbilo, a asserty pod tím chybným se vůbec neprovedou.

Malé testy s popisným jménem řeknou víc: výpis s -v je pak seznam toho, co funkce umí, a červený řádek ukáže přesně na to, co nefunguje.

Kdy testů stačí

Žádné pravidlo neexistuje. Dobré znamení je, když si zkusíš ve funkci udělat chybu – třeba >= 90 přepsat na > 90 – a aspoň jeden test zčervená. Zkus to.


Zpět na téma: Pytest · Další: Testy v projektu

Zdrojový Python soubor

Testy v projektu

Tenhle soubor se nespouští, je to jen čtení. Ukazuje, jak jsou testy uspořádané v projektech na workshopu.

Zatím byla funkce i testy v jednom souboru. V opravdovém projektu se to rozdělí na tři soubory. Na workshopu je takhle uspořádaný každý projekt, třeba projekt-finance:

finance.py logika: funkce, které počítají a vrací výsledky app.py program: menu, input a print, volá funkce z finance.py test_finance.py testy funkcí z finance.py

Test si funkci půjčí

Testy jsou v jiném souboru než funkce, takže si je musí naimportovat. Je to import vlastního modulu z lekce o modulech, stejně jako import prevody v test_prevody.py:

import finance

def test_zustatek_bez_transakci(): assert finance.zustatek([]) == 0

Soubor s testy musí být ve stejné složce jako soubor s funkcemi.

Proč logika zvlášť

Testovat jde funkci, která něco vrací. Funkce, která se ptá přes input, by při testu čekala, až někdo něco napíše. Funkce, která jen vypíše print, nevrací nic, s čím by assert mohl porovnat.

Proto je logika ve finance.py bez inputu a printu. Všechno, co se ptá a vypisuje, je v app.py. Stejně jako prevody.py a program 04_program_a_logika.py v lekci o modulech.

Pozor, z lekce o modulech víš, že import spustí celý soubor. Kdyby ve finance.py byl input mimo funkci, testy by se zasekly a čekaly na odpověď.

Jména souborů

Soubor s testy se jmenuje test_ a za tím jméno souboru, který testuje: test_finance.py testuje finance.py.

Díky začátku test_ ho pytest najde sám. Nemusíš mu říkat, který soubor má spustit – v terminálu stačí:

python -m pytest

Pytest projde složky, najde všechny soubory test_*.py a v nich všechny funkce test_*.

Panel Testing

Ve VS Code nemusíš psát do terminálu vůbec. Vlevo je ikona baňky, panel Testing. Ukáže strom: složky, soubory s testy a v nich jednotlivé testy.

Když panel testy nevidí, klikni nahoře v panelu na tlačítko Refresh Tests (kolečková šipka).

V repozitáři workshopu je VS Code nastavený tak, že panel testy najde, když otevřeš celou složku workshopu (File → Open Folder).

Soubory v téhle lekci schválně nezačínají test_. Panel je proto nevidí a jejich červené testy se nepletou mezi testy projektů.

Jak se s testy pracuje

V projektu se střídá pořád to samé:

  1. V zadání kroku je popsaná funkce a testy k ní.

  2. Testy zkopíruješ do test_….py. Jsou červené, funkce ještě neexistuje.

  3. Píšeš funkci, dokud testy nezezelenají.

  4. Spustíš všechny testy, ne jen ty nové. Když zčervená starý test, nová změna rozbila něco, co už fungovalo.

V pozdějších krocích hotové testy nedostaneš. V zadání bude jen, co má funkce umět, a testy napíšeš sama – podle tří otázek z minulého souboru.


Zpět na téma: Pytest · Další: Cvičení: Pytest

Zdrojový Python soubor

Cvičení: Pytest

Každé cvičení má vlastní soubor ve složce lekce-testovani/02_pytest/cviceni/. Otevři ho ve VS Code, doplň kód pod zadání a soubor spusť (Run). Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Cvičení 1

Soubor: cviceni/01_prepis_na_pytest.py

Přepiš asserty dole na testy pro pytest: každý do vlastní funkce s popisným jménem. Pak testy spusť.

Testy spouštěj v terminálu, který stojí ve složce cviceni (pravým tlačítkem na složku → Open in Integrated Terminal):

python -m pytest 01_prepis_na_pytest.py -v

def je_sude(cislo):
    return cislo % 2 == 0

assert je_sude(4)
assert not je_sude(7)
assert je_sude(0)
assert not je_sude(-3)
Zobrazit řešeníSkrýt řešení
def je_sude(cislo):
    return cislo % 2 == 0

def test_ctyrka_je_suda():
    assert je_sude(4)

def test_sedmicka_neni_suda():
    assert not je_sude(7)

def test_nula_je_suda():
    assert je_sude(0)

def test_zaporne_liche_cislo_neni_sude():
    assert not je_sude(-3)

Výpis s -v končí 4 passed.

Asserty pod funkcemi už v souboru zůstat nemají. Pytest při načítání souboru provede všechno, co není uvnitř funkce, a kdyby některý z nich neplatil, spadlo by to ještě před prvním testem.

Cvičení 2

Soubor: cviceni/02_samohlasky.py

Napiš testy k funkci podle zadání. Funkce je správně, takže všechny tvoje testy mají projít.

Spouštěj v terminálu ve složce cviceni:

python -m pytest 02_samohlasky.py -v

Funkce pocet_samohlasek vrátí, kolik je v textu samohlásek a, e, i, o, u, y. Počítá malá i velká písmena. Písmena s čárkou nebo kroužkem (á, ů…) nepočítá.

def pocet_samohlasek(text):
    pocet = 0
    for znak in text.lower():
        if znak in "aeiouy":
            pocet = pocet + 1
    return pocet

Sem napiš testy. Mysli na tři otázky ze souboru 03_co_testovat.py: obyčejný případ, okraje a vstup, který je nějak zvláštní.

Zobrazit řešeníSkrýt řešení
def pocet_samohlasek(text):
    pocet = 0
    for znak in text.lower():
        if znak in "aeiouy":
            pocet = pocet + 1
    return pocet

def test_jedno_slovo():
    assert pocet_samohlasek("pes") == 1

def test_vic_slov():
    assert pocet_samohlasek("ahoj svete") == 4

def test_velka_pismena_se_pocitaji():
    assert pocet_samohlasek("AHOJ") == 2

def test_y_je_samohlaska():
    assert pocet_samohlasek("byt") == 1

def test_prazdny_text_ma_nula_samohlasek():
    assert pocet_samohlasek("") == 0

def test_slovo_bez_samohlasek():
    assert pocet_samohlasek("brrr") == 0

def test_pismena_s_carkou_se_nepocitaji():
    assert pocet_samohlasek("líný") == 0

Tvoje testy můžou vypadat jinak, hlavně ať pokrývají zadání.

Každá věta zadání si zaslouží aspoň jeden test: velká písmena, y mezi samohláskami, písmena s čárkou. Zbytek jsou okraje: prázdný text a text, ve kterém samohláska není.

Cvičení 3

Soubor: cviceni/03_prumer.py

Napiš testy podle zadání. Jeden z nich neprojde. Přečti si výpis a oprav funkci.

Spouštěj v terminálu ve složce cviceni:

python -m pytest 03_prumer.py

Ověř aspoň tohle:

Funkce prumer vrátí průměr čísel v seznamu. Pro prázdný seznam vrátí 0.

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

Sem napiš testy:

Zobrazit řešeníSkrýt řešení

Opravená funkce. Pod ní je, jak se na chybu přišlo.

def prumer(cisla):
    if len(cisla) == 0:
        return 0
    return sum(cisla) / len(cisla)

def test_prumer_tri_cisel():
    assert prumer([2, 4, 9]) == 5

def test_prumer_jednoho_cisla():
    assert prumer([7]) == 7

def test_prumer_prazdneho_seznamu_je_nula():
    assert prumer([]) == 0

S původní funkcí neprojde test prázdného seznamu, ale jinak, než jsi zvyklá. Výpis má dvě patra, jako chybové hlášky z lekce 7:

def test_prumer_prazdneho_seznamu_je_nula(): > assert prumer([]) == 0

cisla = []

def prumer(cisla): > return sum(cisla) / len(cisla) E ZeroDivisionError: division by zero

Horní patro je test, odkud se funkce zavolala. Spodní je místo, kde to spadlo – uvnitř funkce prumer. Nad ním pytest vypsal, s čím byla funkce zavolaná: cisla = [].

Test tedy nespadl na tom, že by tvrzení neplatilo. Spadl dřív, když funkce počítala. Poznáš to podle posledního řádku s E: místo assert … je tam jméno chyby, tady ZeroDivisionError.

Prázdný seznam má délku nula a dělit nulou nejde. Funkce se na něj musí zeptat dřív, než dělí.

Cvičení 4

Soubor: cviceni/04_kdo_ma_pravdu.py

Spusť testy. Dva neprojdou: jednou je chyba ve funkci, jednou v testu. Podle zadání rozhodni, co je co, a oprav to.

Spouštěj v terminálu ve složce cviceni:

python -m pytest 04_kdo_ma_pravdu.py

Funkce delka_filmu dostane délku filmu v minutách a vrátí ji jako text v hodinách a minutách. Film kratší než hodina má jen minuty.

delka_filmu(90) → "1 h 30 min" delka_filmu(45) → "45 min"

def delka_filmu(minuty):
    hodiny = minuty // 60
    zbytek = minuty % 60
    return f"{hodiny} h {zbytek} min"

def test_hodina_a_pul():
    assert delka_filmu(90) == "1 h 30 min"

def test_kratky_film_ma_jen_minuty():
    assert delka_filmu(45) == "45 min"

def test_dve_hodiny_a_kousek():
    assert delka_filmu(125) == "2 h 15 min"

def test_presne_dve_hodiny():
    assert delka_filmu(120) == "2 h 0 min"
Zobrazit řešeníSkrýt řešení

Opravená funkce a opravený test. Pod nimi je, jak se to poznalo.

def delka_filmu(minuty):
    hodiny = minuty // 60
    zbytek = minuty % 60
    if hodiny == 0:
        return f"{zbytek} min"
    return f"{hodiny} h {zbytek} min"

def test_hodina_a_pul():
    assert delka_filmu(90) == "1 h 30 min"

def test_kratky_film_ma_jen_minuty():
    assert delka_filmu(45) == "45 min"

def test_dve_hodiny_a_kousek():
    assert delka_filmu(125) == "2 h 5 min"

def test_presne_dve_hodiny():
    assert delka_filmu(120) == "2 h 0 min"

Chyba ve funkci – test_kratky_film_ma_jen_minuty

E AssertionError: assert '0 h 45 min' == '45 min'

Zadání říká, že film kratší než hodina má jen minuty. Test čeká přesně to, takže má pravdu a opravuje se funkce.

Chyba v testu – test_dve_hodiny_a_kousek

E AssertionError: assert '2 h 5 min' == '2 h 15 min'

125 minut je dvě hodiny (120) a pět minut. Funkce počítá dobře, ten, kdo psal test, se přepočítal. Opravuje se test.

Výsledek, který test čeká, si vždycky spočítej ručně a pečlivě. Špatně spočítaný test tě pošle hledat chybu tam, kde žádná není.

Cvičení 5

Soubor: cviceni/05_nejdriv_testy.py

Testy už jsou hotové, chybí funkce. Napiš ji tak, aby všechny testy prošly.

Spouštěj v terminálu ve složce cviceni:

python -m pytest 05_nejdriv_testy.py

Na začátku jsou všechny testy červené. Nevadí to – piš funkci a spouštěj testy znovu, dokud nezezelenají. Takhle budeš pracovat i v projektu na workshopu.

Funkce inicialy dostane celé jméno a vrátí iniciály: první písmeno jména a příjmení, každé s tečkou, mezi nimi mezera.

def inicialy(cele_jmeno):
    pass        # pass nic nedělá, jen drží místo. Nahraď ho svým kódem.

def test_jmeno_a_prijmeni():
    assert inicialy("Jana Nováková") == "J. N."

def test_mala_pismena_se_zvetsi():
    assert inicialy("eva malá") == "E. M."

def test_mezery_navic_nevadi():
    assert inicialy("  Petra   Svobodová ") == "P. S."
Zobrazit řešeníSkrýt řešení
def inicialy(cele_jmeno):
    casti = cele_jmeno.split()
    jmeno = casti[0]
    prijmeni = casti[1]
    return f"{jmeno[0].upper()}. {prijmeni[0].upper()}."

def test_jmeno_a_prijmeni():
    assert inicialy("Jana Nováková") == "J. N."

def test_mala_pismena_se_zvetsi():
    assert inicialy("eva malá") == "E. M."

def test_mezery_navic_nevadi():
    assert inicialy("  Petra   Svobodová ") == "P. S."

split() bez argumentu rozdělí text podle mezer a mezery navíc zahodí, i ty na začátku a na konci. Proto třetí test projde bez strip.

Kdybys rozdělovala split(" "), třetí test neprojde: mezi dvěma mezerami vznikne prázdný kus "" a casti[0] by bylo právě ono. Přesně kvůli takovým věcem má test s mezerami navíc smysl.

Na začátku funkce obsahovala jen pass a nic nevracela. Testy proto hlásily assert None == 'J. N.' – funkce bez return vrací None.


Zpět na téma: Pytest · Další: Bonusová cvičení: Pytest

Zdrojové soubory na GitHubu

Bonusová cvičení: Pytest

Bonusy jsou pro rychlíky – když máš hotová cvičení a zbývá čas. Každý bonus má vlastní soubor ve složce lekce-testovani/02_pytest/cviceni_bonusy/. Řešení si rozklikni až po vlastním pokusu – tvoje řešení může vypadat jinak, a to je v pořádku.

Bonus 1

Soubor: cviceni_bonusy/01_nejdelsi_slovo.py

Napiš testy podle zadání. Ve funkci je chyba, která se ukáže jen na jednom z okrajů. Najdi ho a funkci oprav.

Spouštěj v terminálu ve složce cviceni_bonusy:

python -m pytest 01_nejdelsi_slovo.py

Funkce nejdelsi_slovo vrátí nejdelší slovo z věty. Když je nejdelších slov víc stejně dlouhých, vrátí to, které je ve větě první. Pro prázdný text vrátí prázdný text "".

def nejdelsi_slovo(veta):
    nejdelsi = ""
    for slovo in veta.split():
        if len(slovo) >= len(nejdelsi):
            nejdelsi = slovo
    return nejdelsi

Sem napiš testy:

Zobrazit řešeníSkrýt řešení

Opravená funkce. Pod ní je, který test chybu našel.

def nejdelsi_slovo(veta):
    nejdelsi = ""
    for slovo in veta.split():
        if len(slovo) > len(nejdelsi):
            nejdelsi = slovo
    return nejdelsi

def test_nejdelsi_slovo_ve_vete():
    assert nejdelsi_slovo("pes leží na zahradě") == "zahradě"

def test_nejdelsi_slovo_na_konci():
    assert nejdelsi_slovo("já mám ráda programování") == "programování"

def test_jedno_slovo():
    assert nejdelsi_slovo("ahoj") == "ahoj"

def test_prazdny_text():
    assert nejdelsi_slovo("") == ""

def test_dve_stejne_dlouha_slova_vrati_prvni():
    assert nejdelsi_slovo("pes kos") == "pes"

Chybu našel jen poslední test. Funkce měla >=, takže stejně dlouhé slovo, které přišlo později, přepsalo to dřívější. Vrátila kos místo pes.

Zbylé testy by prošly i s chybou. Každá věta zadání, která začíná „když“, je kandidát na vlastní test.

Bonus 2

Soubor: cviceni_bonusy/02_puvodni_seznam.py

Funkce vrací správný výsledek, a přesto má chybu. Napiš test, který ji odhalí, a pak funkci oprav.

Spouštěj v terminálu ve složce cviceni_bonusy:

python -m pytest 02_puvodni_seznam.py

Funkce tri_nejlevnejsi dostane seznam cen a vrátí nový seznam se třemi nejnižšími cenami od nejmenší. Původní seznam nechá tak, jak byl.

def tri_nejlevnejsi(ceny):
    ceny.sort()
    return ceny[:3]

def test_tri_nejlevnejsi():
    assert tri_nejlevnejsi([500, 120, 80, 300, 90]) == [80, 90, 120]

Tenhle test projde. Napiš další, který ověří poslední větu zadání. Nápověda: seznam si ulož do proměnné, zavolej funkci a pak se podívej, co je v proměnné.

Zobrazit řešeníSkrýt řešení

Opravená funkce. Pod ní je, co bylo špatně.

def tri_nejlevnejsi(ceny):
    serazene = sorted(ceny)
    return serazene[:3]

def test_tri_nejlevnejsi():
    assert tri_nejlevnejsi([500, 120, 80, 300, 90]) == [80, 90, 120]

def test_puvodni_seznam_zustane_stejny():
    ceny = [500, 120, 80, 300, 90]
    tri_nejlevnejsi(ceny)
    assert ceny == [500, 120, 80, 300, 90]

S původní funkcí druhý test neprojde:

E assert [80, 90, 120, 300, 500] == [500, 120, 80, 300, 90]

sort mění seznam, na kterém ho zavoláš – to znáš z lekce 8. Funkce tak seřadila i seznam, který jí někdo poslal. Kdo by ho po zavolání dál používal, měl by v něm najednou jiné pořadí.

sorted(ceny) je vestavěná funkce, která vrátí nový seřazený seznam a původní nechá být. Jde to i bez ní: ceny[:] udělá kopii seznamu a teprve na té se zavolá sort.

kopie = ceny[:]
kopie.sort()
return kopie[:3]

Proto v projektu na workshopu volá každý test ukazka() a dostane vlastní čerstvý seznam. Kdyby testy sdílely jeden, funkce, která ho změní, by rozbila testy po ní.

Bonus 3

Soubor: cviceni_bonusy/03_test_modulu.py

Tenhle soubor jen přečti, kód piš do nového souboru.

Napiš testy k modulu, tak jako budou vypadat v projektech.

Vedle tohohle souboru leží modul spropitne.py. Je stejný jako ten, který sis psala v lekci o modulech.

  1. Ve složce cviceni_bonusy vytvoř soubor test_spropitne.py. Jméno musí začínat na test_, jinak ho pytest nenajde.

  2. Nahoře naimportuj modul: import spropitne

  3. Napiš aspoň tři testy, každý jako funkci začínající na test_:

  1. Spusť je v panelu Testing a dívej se, jestli svítí zeleně.

Jak takový test vypadá, uvidíš v 04_testy_v_projektu.py a v lekce-moduly/03_vlastni_moduly/test_prevody.py.

Zobrazit řešeníSkrýt řešení

U tebe se tenhle soubor jmenuje test_spropitne.py a leží ve složce cviceni_bonusy vedle spropitne.py. Tady má jméno podle zadání, a tak ho pytest sám nenajde. Spustíš ho jménem v terminálu ve složce reseni:

python -m pytest 03_test_modulu.py

Modul spropitne.py je kvůli tomu zkopírovaný i sem.

import spropitne

def test_deset_procent():
    assert spropitne.spropitne(500, 10) == 50

def test_nulova_castka():
    assert spropitne.spropitne(0, 10) == 0

def test_celkem():
    assert spropitne.celkem(500, 10) == 550

Zpět na téma: Pytest

Zdrojové soubory na GitHubu