Scrivere un test, esercizi spiegati
Sei funzioni giuste, e i test di Nadia
- 25 minuti di lettura
Sei esempi. In ognuno Nadia Russo ha davanti una funzione e scrive i suoi test. Ogni esempio ha lo stesso ritmo:
- Prevedi: leggi il codice e scrivi su un foglio cosa dice pytest. Prima di aprire la risposta.
- In italiano: cosa prova il test, a parole.
- Passo per passo: cosa succede, una riga alla volta.
- Cosa portiamo a casa: la cosa da ricordare.
Tutti gli output sono usciti davvero da pytest. Ho tolto solo le righe con i percorsi del computer. Per provarli: una cartella nuova, il venv acceso, un file per il codice e uno per il test (il nome del test comincia con test_), poi pytest. Come si lancia e come si legge l'output: Lanciare i test.
A · Quanti tornelli funzionano?
La funzione di Porta Codice conta i tornelli aperti: tutti, meno quelli guasti. Nadia scrive il suo primo test. Ma qualcuno, nella notte, ha toccato la funzione.
# varchi.py
def varchi_aperti(totale: int, guasti: int) -> int:
"""I tornelli che funzionano: tutti meno quelli guasti."""
return totale - guasti - 1# test_varchi.py
from varchi import varchi_aperti
def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
assert varchi_aperti(6, 1) == 5Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Il test è rosso. Sei tornelli e uno guasto fanno cinque, ma la funzione ha un - 1 di troppo e dà quattro.
============================= test session starts ==============================
collected 1 item
test_varchi.py F [100%]
=================================== FAILURES ===================================
_______________ test_i_varchi_aperti_sono_i_totali_meno_i_guasti _______________
def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
> assert varchi_aperti(6, 1) == 5
E assert 4 == 5
E + where 4 = varchi_aperti(6, 1)
test_varchi.py:5: AssertionError
=========================== short test summary info ============================
FAILED test_varchi.py::test_i_varchi_aperti_sono_i_totali_meno_i_guasti - ass...
============================== 1 failed in 0.01s ===============================Si legge dal basso: FAILED dice quale test, la riga con > dice quale assert, le righe E dicono cosa è uscito (4) e cosa ci si aspettava (5).
In italiano. Il test chiama la funzione con 6 tornelli e 1 guasto, e afferma che il risultato è 5.
Passo per passo.
| Fase | Riga | Cosa succede |
|---|---|---|
| Prepara | 6 e 1 | i dati di partenza, scritti direttamente nella chiamata |
| Esegui | varchi_aperti(6, 1) | la funzione risponde 4 |
| Verifica | assert … == 5 | 4 == 5 è falso: il test diventa rosso |
Togliamo il - 1 dalla funzione e rilanciamo: 1 passed. Il test c'è per questo: è rosso quando il codice sbaglia, verde quando è giusto.
Adesso la stessa funzione, sempre con il - 1 di troppo, ma con un test dove Nadia ha dimenticato una parola:
def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
varchi_aperti(6, 1) == 5Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
============================= test session starts ==============================
collected 1 item
test_varchi.py . [100%]
============================== 1 passed in 0.00s ===============================Verde, con il codice sbagliato. Senza assert Python calcola 4 == 5, trova False, e lo butta via. Nessuno gli ha chiesto di arrabbiarsi.
Cosa portiamo a casa. Un test senza assert è sempre verde. Un test verde ti dice qualcosa solo se lo hai visto, almeno una volta, diventare rosso con il codice sbagliato.
B · Il bagaglio: un test per comportamento
Alla biglietteria di Largo Lista i bagagli hanno tre classi: leggero fino a 10 kg compresi, medio fino a 23 compresi, pesante oltre. Il codice ha un errore sul confine dei 10 kg: ha scritto kg < 10 invece di kg <= 10.
# bagagli.py
def classe_bagaglio(kg: float) -> str:
"""leggero fino a 10 kg compresi, medio fino a 23 compresi, poi pesante."""
if kg < 10:
return "leggero"
if kg <= 23:
return "medio"
return "pesante"Prima versione del test, un test solo:
def test_classe_bagaglio():
assert classe_bagaglio(4) == "leggero"
assert classe_bagaglio(10) == "leggero"
assert classe_bagaglio(23) == "medio"
assert classe_bagaglio(30) == "pesante"Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
============================= test session starts ==============================
collected 1 item
test_bagagli.py F [100%]
=================================== FAILURES ===================================
_____________________________ test_classe_bagaglio _____________________________
def test_classe_bagaglio():
assert classe_bagaglio(4) == "leggero"
> assert classe_bagaglio(10) == "leggero"
E AssertionError: assert 'medio' == 'leggero'
E
E - leggero
E + medio
test_bagagli.py:6: AssertionError
=========================== short test summary info ============================
FAILED test_bagagli.py::test_classe_bagaglio - AssertionError: assert 'medio'...
============================== 1 failed in 0.01s ===============================Il test trova l'errore, ma il nome non dice niente, e il secondo assert ha fermato tutto: le righe con 23 e 30 non sono mai state eseguite. Non sai se vanno bene.
In italiano. Un test per ogni comportamento, con un nome che lo racconta.
def test_un_bagaglio_di_pochi_chili_e_leggero():
assert classe_bagaglio(4) == "leggero"
def test_dieci_chili_sono_ancora_un_bagaglio_leggero():
assert classe_bagaglio(10) == "leggero"
def test_ventitre_chili_sono_ancora_un_bagaglio_medio():
assert classe_bagaglio(23) == "medio"
def test_oltre_ventitre_chili_e_pesante():
assert classe_bagaglio(30) == "pesante"Con pytest -v:
============================= test session starts ==============================
collecting ... collected 4 items
test_bagagli.py::test_un_bagaglio_di_pochi_chili_e_leggero PASSED [ 25%]
test_bagagli.py::test_dieci_chili_sono_ancora_un_bagaglio_leggero FAILED [ 50%]
test_bagagli.py::test_ventitre_chili_sono_ancora_un_bagaglio_medio PASSED [ 75%]
test_bagagli.py::test_oltre_ventitre_chili_e_pesante PASSED [100%]
=================================== FAILURES ===================================
_______________ test_dieci_chili_sono_ancora_un_bagaglio_leggero _______________
def test_dieci_chili_sono_ancora_un_bagaglio_leggero():
> assert classe_bagaglio(10) == "leggero"
E AssertionError: assert 'medio' == 'leggero'
E
E - leggero
E + medio
test_bagagli.py:9: AssertionError
=========================== short test summary info ============================
FAILED test_bagagli.py::test_dieci_chili_sono_ancora_un_bagaglio_leggero - As...
========================= 1 failed, 3 passed in 0.01s ==========================Passo per passo.
| Test | Cosa prova | Esito |
|---|---|---|
test_un_bagaglio_di_pochi_chili_e_leggero | il caso facile | verde |
test_dieci_chili_sono_ancora_un_bagaglio_leggero | il confine tra leggero e medio | rosso |
test_ventitre_chili_sono_ancora_un_bagaglio_medio | il confine tra medio e pesante | verde |
test_oltre_ventitre_chili_e_pesante | un caso pesante | verde |
Il nome del test rosso dice già tutto: dieci chili dovrebbero essere ancora leggeri. Non serve aprire il file per capire cosa si è rotto.
Cosa portiamo a casa. Un comportamento, un test; il nome si legge come una frase. Il caso facile (4 kg) lo passa anche il codice sbagliato: sono i confini che lo smascherano.
C · Il totale dello scontrino
Il distributore di Via Variabile somma i prezzi di uno scontrino. Nadia prova due caffè da 10 e 20 centesimi.
# scontrino.py
def totale_scontrino(prezzi: list[float]) -> float:
"""La somma dei prezzi, senza arrotondare."""
return sum(prezzi)# test_scontrino.py
from scontrino import totale_scontrino
def test_il_totale_somma_i_prezzi():
assert totale_scontrino([0.10, 0.20]) == 0.30Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Rosso, anche se la funzione è giusta.
============================= test session starts ==============================
collected 1 item
test_scontrino.py F [100%]
=================================== FAILURES ===================================
________________________ test_il_totale_somma_i_prezzi _________________________
def test_il_totale_somma_i_prezzi():
> assert totale_scontrino([0.10, 0.20]) == 0.30
E assert 0.30000000000000004 == 0.3
E + where 0.30000000000000004 = totale_scontrino([0.1, 0.2])
test_scontrino.py:5: AssertionError
=========================== short test summary info ============================
FAILED test_scontrino.py::test_il_totale_somma_i_prezzi - assert 0.3000000000...
============================== 1 failed in 0.01s ===============================0.1 + 0.2 nel computer non fa esattamente 0.3: fa 0.30000000000000004. Non è un bug della funzione: è come si scrivono i numeri con la virgola.
In italiano. Il test deve dire «uguale a 0,30, a meno di un'inezia». Si scrive con pytest.approx.
import pytest
from scontrino import totale_scontrino
def test_il_totale_somma_i_prezzi():
assert totale_scontrino([0.10, 0.20]) == pytest.approx(0.30)Con pytest -v:
============================= test session starts ==============================
collecting ... collected 1 item
test_scontrino.py::test_il_totale_somma_i_prezzi PASSED [100%]
============================== 1 passed in 0.00s ===============================Ora la prova che approx non è un colabrodo. Nella funzione mettiamo uno sbaglio vero (+ 0.5):
E assert 0.8 == 0.3 ± 3.0e-07
E
E comparison failed
E Obtained: 0.8
E Expected: 0.3 ± 3.0e-07± 3.0e-07 è la tolleranza: tre decimilionesimi. Tanto basta per l'inezia dei numeri con la virgola, e un errore vero resta rosso.
Cosa portiamo a casa. Con i numeri con la virgola calcolati, mai ==: pytest.approx. Se scrivi una tolleranza tua (abs=0.01), tienila stretta: più è larga, più errori lascia passare.
D · L'orario che non esiste
La funzione che legge gli orari del tabellone trasforma «06:45» in minuti dalla mezzanotte. Un orario impossibile, come «25:10», deve dare ValueError.
# orari.py
def ora_in_minuti(orario: str) -> int:
"""Da «06:45» ai minuti dalla mezzanotte. Un orario impossibile è un ValueError."""
ore_testo, minuti_testo = orario.split(":")
ore = int(ore_testo)
minuti = int(minuti_testo)
if ore > 23 or minuti > 59:
raise ValueError(f"Orario impossibile: {orario}")
return ore * 60 + minutiIl disegno.
Nadia prova a scrivere il test dell'errore così:
def test_un_orario_impossibile_e_un_errore():
assert ora_in_minuti("25:10") == ValueErrorPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Rosso, e non per il motivo che pensava Nadia.
============================= test session starts ==============================
collected 1 item
test_orari.py F [100%]
=================================== FAILURES ===================================
____________________ test_un_orario_impossibile_e_un_errore ____________________
def test_un_orario_impossibile_e_un_errore():
> assert ora_in_minuti("25:10") == ValueError
^^^^^^^^^^^^^^^^^^^^^^
test_orari.py:5:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
orario = '25:10'
def ora_in_minuti(orario: str) -> int:
"""Da «06:45» ai minuti dalla mezzanotte. Un orario impossibile è un ValueError."""
ore_testo, minuti_testo = orario.split(":")
ore = int(ore_testo)
minuti = int(minuti_testo)
if ore > 23 or minuti > 59:
> raise ValueError(f"Orario impossibile: {orario}")
E ValueError: Orario impossibile: 25:10
orari.py:7: ValueError
=========================== short test summary info ============================
FAILED test_orari.py::test_un_orario_impossibile_e_un_errore - ValueError: Or...
============================== 1 failed in 0.01s ===============================L'errore è arrivato, giusto, ma l'assert non lo aspettava: ora_in_minuti("25:10") solleva l'errore prima di poter restituire qualcosa da confrontare. L'errore non è un valore: è un'interruzione. Per aspettarlo serve un attrezzo fatto apposta.
In italiano. Dico a pytest: «dentro questo blocco mi aspetto un ValueError, e nel messaggio deve comparire l'orario».
import pytest
from orari import ora_in_minuti
def test_un_orario_si_converte_in_minuti():
assert ora_in_minuti("06:45") == 405
def test_un_orario_impossibile_e_un_errore():
with pytest.raises(ValueError, match="25:10"):
ora_in_minuti("25:10")============================= test session starts ==============================
collecting ... collected 2 items
test_orari.py::test_un_orario_si_converte_in_minuti PASSED [ 50%]
test_orari.py::test_un_orario_impossibile_e_un_errore PASSED [100%]
============================== 2 passed in 0.00s ===============================Ora una versione sbagliata della funzione: il controllo delle ore è stato tolto (ore > 99 al posto di ore > 23). Il test con pytest.raises(ValueError) diventa rosso:
def test_un_orario_impossibile_e_un_errore():
> with pytest.raises(ValueError):
^^^^^^^^^^^^^^^^^^^^^^^^^
E Failed: DID NOT RAISE ValueError
test_orari.py:6: FailedDID NOT RAISE vuol dire: l'errore doveva arrivare e non è arrivato.
Passo per passo.
| Scrivi | Dove | Cosa fa |
|---|---|---|
raise ValueError(…) | nella funzione | segnala l'errore |
assert … | nel test | controlla un valore |
with pytest.raises(ValueError): | nel test | controlla che l'errore arrivi |
Cosa portiamo a casa. Si prova anche l'errore, con pytest.raises e il tipo preciso. Con match= provi anche il messaggio. pytest.raises(Exception) è troppo largo: prenderebbe anche un bug che non c'entra niente.
E · Le fasce orarie, ai confini
Il tabellone cambia colore secondo l'ora: notte fino alle 5 comprese, punta dalle 7 alle 9 comprese, il resto è giorno.
# fasce.py
def fascia_oraria(ora: int) -> str:
"""notte fino alle 5 comprese, punta dalle 7 alle 9 comprese, poi giorno."""
if ora <= 5:
return "notte"
if 7 <= ora <= 9:
return "punta"
return "giorno"Il disegno.
I valori che contano sono i confini: 5 e 6, 7, 9 e 10. Sei test quasi uguali? No: uno solo, con parametrize.
import pytest
from fasce import fascia_oraria
@pytest.mark.parametrize(
("ora", "fascia"),
[
(0, "notte"),
(5, "notte"),
(6, "giorno"),
(7, "punta"),
(9, "punta"),
(10, "giorno"),
],
)
def test_la_fascia_cambia_ai_confini(ora, fascia):
assert fascia_oraria(ora) == fasciaPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Sei test, tutti verdi. Ognuno ha il suo nome, con i valori dentro le parentesi quadre.
============================= test session starts ==============================
collecting ... collected 6 items
test_fasce.py::test_la_fascia_cambia_ai_confini[0-notte] PASSED [ 16%]
test_fasce.py::test_la_fascia_cambia_ai_confini[5-notte] PASSED [ 33%]
test_fasce.py::test_la_fascia_cambia_ai_confini[6-giorno] PASSED [ 50%]
test_fasce.py::test_la_fascia_cambia_ai_confini[7-punta] PASSED [ 66%]
test_fasce.py::test_la_fascia_cambia_ai_confini[9-punta] PASSED [ 83%]
test_fasce.py::test_la_fascia_cambia_ai_confini[10-giorno] PASSED [100%]
============================== 6 passed in 0.01s ===============================In italiano. Pytest lancia la funzione di test una volta per ogni riga della lista. La prima colonna diventa il parametro ora, la seconda il parametro fascia.
Ora qualcuno cambia il codice: 7 <= ora < 9, che toglie le 9 dalla punta. Nessun test «facile» se ne accorge: le 8 sarebbero ancora punta. Il test con i confini sì:
test_fasce.py ....F. [100%]
=================================== FAILURES ===================================
__________________ test_la_fascia_cambia_ai_confini[9-punta] ___________________
ora = 9, fascia = 'punta'
@pytest.mark.parametrize(
("ora", "fascia"),
[
(0, "notte"),
(5, "notte"),
(6, "giorno"),
(7, "punta"),
(9, "punta"),
(10, "giorno"),
],
)
def test_la_fascia_cambia_ai_confini(ora, fascia):
> assert fascia_oraria(ora) == fascia
E AssertionError: assert 'giorno' == 'punta'
E
E - punta
E + giorno
test_fasce.py:17: AssertionError
=========================== short test summary info ============================
FAILED test_fasce.py::test_la_fascia_cambia_ai_confini[9-punta] - AssertionEr...
========================= 1 failed, 5 passed in 0.01s ==========================Dei sei, uno solo è rosso, e il suo nome dice quale: [9-punta].
Passo per passo.
| Confine | Valori da provare | Perché |
|---|---|---|
| notte / giorno | 5 e 6 | l'ultimo valore di notte e il primo dopo |
| giorno / punta | 6 e 7 | l'ultimo prima della punta e il primo dentro |
| punta / giorno | 9 e 10 | l'ultimo valore di punta e il primo dopo |
Cosa portiamo a casa. Con parametrize aggiungere un caso costa una riga. I valori da scegliere sono quelli dove il comportamento cambia, da una parte e dall'altra.
F · Il terreno di prova
L'ultimo caso: funzioni che stampano e funzioni che scrivono un file. Non hanno un return da confrontare.
# avvisi.py
from pathlib import Path
def stampa_avviso(treno: str, minuti: int) -> None:
print(f"Il treno {treno} ha {minuti} minuti di ritardo")
def salva_ritardi(percorso: Path, ritardi: dict[str, int]) -> None:
with open(percorso, "w", encoding="utf-8") as file:
for treno, minuti in ritardi.items():
file.write(f"{treno},{minuti}\n")Tre aiutanti di pytest, chiesti per nome come parametri del test:
import pytest
from avvisi import salva_ritardi, stampa_avviso
@pytest.fixture
def ritardi():
return {"M12": 5, "T28": 0}
def test_l_avviso_dice_treno_e_minuti(capsys):
stampa_avviso("M12", 5)
uscita = capsys.readouterr()
assert uscita.out == "Il treno M12 ha 5 minuti di ritardo\n"
def test_il_file_ha_una_riga_per_treno(tmp_path, ritardi):
file = tmp_path / "ritardi.csv"
salva_ritardi(file, ritardi)
assert file.read_text(encoding="utf-8") == "M12,5\nT28,0\n"
def test_il_file_si_legge_riga_per_riga(tmp_path, ritardi):
file = tmp_path / "ritardi.csv"
salva_ritardi(file, ritardi)
righe = file.read_text(encoding="utf-8").splitlines()
assert righe == ["M12,5", "T28,0"]Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Tre verdi.
============================= test session starts ==============================
collecting ... collected 3 items
test_avvisi.py::test_l_avviso_dice_treno_e_minuti PASSED [ 33%]
test_avvisi.py::test_il_file_ha_una_riga_per_treno PASSED [ 66%]
test_avvisi.py::test_il_file_si_legge_riga_per_riga PASSED [100%]
============================== 3 passed in 0.01s ===============================Il disegno.
In italiano.
capsysascolta quello che la funzione stampa. Dopo la chiamata,capsys.readouterr().outè il testo uscito su stdout.tmp_pathè una cartella temporanea e vuota, solo per questo test. Ci scrivi dentro un file, ci fai lavorare la funzione, lo rileggi. Quando il test finisce, pytest la butta via.ritardiè una fixture tua: la funzione con@pytest.fixturesopra restituisce i dati, e i test che la nominano come parametro li ricevono pronti. Due test, gli stessi dati, scritti una volta sola.
Cosa portiamo a casa. Per i file, tmp_path, sempre: mai un percorso scritto a mano. Per quello che una funzione stampa, capsys. Per i dati che servono a più test, una fixture.
Pronto? Gli stessi attrezzi ti aspettano nella palestra: sei esercizi da scaricare. Il codice è già scritto e giusto: i test, tocca a te.