Scrivere un test, le soluzioni
I test giusti, e i test sbagliati che il controllo smaschera
Per ogni esercizio, sempre lo stesso ordine: in italiano → i test → le trappole. Per i più difficili, anche il passo per passo.
I tuoi test sono diversi ma il controllo è verde? Probabilmente vanno bene: lo stesso comportamento si prova in molti modi. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: sono i test che sembrano giusti e lasciano passare un errore.
Nella colonna «Il controllo rosso» i nomi sono abbreviati: davanti a quelli che descrivono uno sbaglio del codice, nel file test_controllo_<nome>.py, c'è test_si_accorgono_se_.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · I posti in carrozza
In italiano. Tre test, tre valori: 39 passeggeri (resta un posto), 40 (nessun posto), 45 (nessun posto, non meno uno).
def test_con_un_passeggero_in_meno_resta_un_posto():
assert posti_liberi(39) == 1
def test_una_carrozza_piena_non_ha_posti_liberi():
assert posti_liberi(40) == 0
def test_i_posti_liberi_non_sono_mai_negativi():
assert posti_liberi(45) == 0Il caso a metà (15 passeggeri) c'era già: lo passa anche il codice sbagliato. Sono gli estremi a smascherarlo.
Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
Solo posti_liberi(15), posti_liberi(2), posti_liberi(20) | Tutti numeri comodi, in mezzo: il codice sbagliato li supera. L'ultimo posto, la carrozza piena e la capienza superata non li prova nessuno | l_ultimo_posto_sparisce, i_posti_liberi_vanno_sotto_zero, una_carrozza_piena_ha_un_posto_libero |
posti_liberi(45) == 0 scritto senza assert | La riga è un confronto buttato via: il test è verde con qualsiasi codice. Il controllo se ne accorge due volte | ogni_tuo_test_controlla_qualcosa, i_posti_liberi_vanno_sotto_zero |
La seconda trappola è la più furba: il test c'è, ha un nome bellissimo, ed è finto. Nel file test_posti_carrozza__senza_assert.py l'ultimo test è proprio questo:
def test_i_posti_liberi_non_sono_mai_negativi():
posti_liberi(45) == 02 · Il tabellone dei treni
In italiano. Un comportamento per test, con il nome che lo racconta: 3 minuti sono ancora in orario, 4 sono un ritardo, un treno soppresso senza ritardo è soppresso.
def test_tre_minuti_di_ritardo_sono_ancora_in_orario():
assert stato_treno(3) == "in orario"
def test_quattro_minuti_di_ritardo_sono_un_ritardo():
assert stato_treno(4) == "in ritardo di 4 minuti"
def test_un_treno_soppresso_e_soppresso_anche_senza_ritardo():
assert stato_treno(0, soppresso=True) == "soppresso"Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
test_uno, test_due, test_tre, test_quattro, tutti con l'assert giusto | I test passano, ma quando uno diventa rosso il nome non dice cosa si è rotto | i_nomi_dei_tuoi_test_dicono_qualcosa |
| Prova 0 minuti, 2 minuti, 10 minuti, e un soppresso con 10 minuti di ritardo | Nessuno prova i valori 3 e 4, dove cambia la risposta. E un soppresso che era già in ritardo non distingue chi controlla prima il ritardo | tre_minuti_sono_gia_un_ritardo, quattro_minuti_sono_ancora_in_orario, un_treno_puntuale_e_soppresso |
Il test del soppresso deve avere zero minuti di ritardo: è lì che l'ordine dei controlli nel codice fa la differenza.
3 · La media dei ritardi
In italiano. Due medie con la virgola, provate con approx, e la lista vuota, che dà 0.0 (un numero esatto, basta ==).
import pytest
def test_la_media_con_la_virgola():
assert media_ritardi([0.1, 0.2]) == pytest.approx(0.15)
def test_la_media_che_non_si_scrive_con_una_cifra_sola():
assert media_ritardi([1, 2, 2]) == pytest.approx(5 / 3)
def test_senza_ritardi_la_media_e_zero():
assert media_ritardi([]) == 0.0Passo per passo.
| Test | Valore atteso | Perché |
|---|---|---|
[0.1, 0.2] | approx(0.15) | 0.1 + 0.2 fa 0.30000000000000004: con == contro 0.15 il test sarebbe rosso sul codice giusto |
[1, 2, 2] | approx(5 / 3) | la media è 1.6666…: scriverla a mano è già un'approssimazione, meglio lasciare la divisione a Python |
[] | 0.0 | un caso speciale: senza ritardi non si divide per zero |
Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
media_ritardi([0.1, 0.2]) == 0.15 | Sul codice giusto il test è rosso: 0.15000000000000002 == 0.15. I test non passano, e nessun controllo successivo può partire | tutti i controlli: i_tuoi_test_passano_sul_codice_giusto, usi_pytest_approx e i quattro si_accorgono |
pytest.approx(0.15, abs=0.1) e lo stesso per le altre medie | I test sono verdi, ma una tolleranza di un decimo di minuto lascia passare una media più alta di un centesimo, e una arrotondata a un solo decimale | la_media_e_troppo_alta_di_un_centesimo, la_media_e_arrotondata_a_un_decimale |
La tolleranza larga è la scorciatoia di chi ha visto il test diventare rosso e ha voluto farlo tornare verde. Quando un test è rosso, prima chiediti perché: spesso approx da solo basta.
4 · La ricarica della tessera
In italiano. Gli errori con pytest.raises e il tipo preciso; gli estremi (1 e 150) si provano come casi normali; il messaggio con match=.
import pytest
def test_sotto_un_euro_la_ricarica_e_un_errore():
with pytest.raises(ValueError):
ricarica(10, 0.5)
def test_sopra_centocinquanta_euro_la_ricarica_e_un_errore():
with pytest.raises(ValueError):
ricarica(10, 151)
def test_un_euro_si_puo_ricaricare():
assert ricarica(0, 1) == 1
def test_centocinquanta_euro_si_possono_ricaricare():
assert ricarica(0, 150) == 150
def test_il_messaggio_dell_errore_dice_l_importo():
with pytest.raises(ValueError, match="151"):
ricarica(10, 151)Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
with pytest.raises(Exception): in tutti i test degli errori | Va bene anche un TypeError al posto del ValueError: un bug qualsiasi passa per l'errore previsto | l_errore_e_di_un_altro_tipo |
| Provati 0.5, 151 e una ricarica da 100, ma non 1 e 150 | Gli errori ci sono, i casi ammessi agli estremi no: un <= al posto di < rifiuterebbe una ricarica da esattamente 1 euro, e nessuno se ne accorgerebbe | un_euro_da_errore, centocinquanta_euro_da_errore |
5 · La tariffa per età
In italiano. Un test solo con parametrize, con i confini: 13 e 14, 64 e 65. Più l'errore per l'età negativa.
import pytest
@pytest.mark.parametrize(
("eta", "prezzo"),
[
(0, 0.0),
(13, 0.0),
(14, 2.2),
(64, 2.2),
(65, 1.1),
(90, 1.1),
],
)
def test_la_tariffa_cambia_ai_confini_delle_eta(eta, prezzo):
assert tariffa(eta) == prezzo
def test_un_eta_negativa_e_un_errore():
with pytest.raises(ValueError):
tariffa(-1)Passo per passo.
| Confine | Valori | Cosa scopre |
|---|---|---|
| gratis / intero | 13 e 14 | un < al posto di <=, o un 14 che sparisce |
| intero / ridotto | 64 e 65 | un >= al posto di >, o il passaggio un anno prima |
0 e 90 | gli estremi | non servono al controllo, ma completano il quadro |
I prezzi si confrontano con ==: la funzione restituisce le costanti 2.2, 1.1 e 0.0 così come sono, senza calcoli. Niente conti, niente inezie da approx.
Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
parametrize con 5, 30 e 80 anni | Un bambino, un adulto, un anziano: nessuno vicino a un confine. Ogni errore di confine passa inosservato | a_tredici_anni_si_paga, a_quattordici_anni_e_ancora_gratis, a_sessantaquattro_anni_c_e_gia_lo_sconto, a_sessantacinque_anni_non_c_e_lo_sconto |
| Sei test separati, uno per valore, copiati e incollati | Provano tutto quello che serve, ma sono sei funzioni quasi uguali: aggiungere un caso vuol dire incollarne un'altra. Qui il controllo guarda la forma | usi_parametrize_per_i_confini |
6 · Il registro delle timbrature
In italiano.
- La fixture
registroscrive un file con l'intestazione e tre timbrature, e restituisce il percorso. - Il primo test conta le tre timbrature, usando la fixture.
- Il secondo scrive un file con la sola intestazione: zero timbrature.
- Il terzo scrive un file che finisce con righe vuote: contano solo le timbrature vere.
import pytest
@pytest.fixture
def registro(tmp_path):
file = tmp_path / "registro.csv"
file.write_text("badge,ora\nB-01,06:10\nB-12,06:14\nB-03,06:20\n", encoding="utf-8")
return file
def test_tre_timbrature_si_contano_tutte(registro):
assert conta_timbrature(registro) == 3
def test_l_intestazione_non_e_una_timbratura(tmp_path):
file = tmp_path / "solo_intestazione.csv"
file.write_text("badge,ora", encoding="utf-8")
assert conta_timbrature(file) == 0
def test_le_righe_vuote_non_sono_timbrature(tmp_path):
file = tmp_path / "con_righe_vuote.csv"
file.write_text("badge,ora\nB-01,06:10\n\n\n", encoding="utf-8")
assert conta_timbrature(file) == 1Passo per passo.
| Cosa | Come | Perché |
|---|---|---|
| Il file di prova | tmp_path / "registro.csv", poi write_text | una cartella temporanea e solo tua: niente percorsi scritti a mano |
| L'a capo | \n dentro la stringa | ogni \n chiude una riga del CSV |
| La fixture | @pytest.fixture sopra def registro(tmp_path) | il file si prepara in un posto solo; il test lo chiede per nome |
| Il file con la sola intestazione | "badge,ora" senza altro | prova che la prima riga non è una timbratura |
| Le righe vuote | un file che finisce con \n\n\n | prova che non si conta ogni riga di testo |
Le trappole.
| I test sbagliati | Cosa succede | Il controllo rosso |
|---|---|---|
La fixture restituisce Path("palestra/registro_di_prova.csv"), un file scritto a mano | Dal tuo computer, lanciando pytest dalla cartella dello zip, il file si trova. Il controllo lavora su una copia della cartella, dove quel percorso non esiste: FileNotFoundError, e i test sono rossi sul codice giusto | i_tuoi_test_passano_sul_codice_giusto, tre_timbrature_si_contano_tutte e tre si_accorgono |
| File di prova scritti senza a capo finale e senza righe vuote | Intestazione e timbrature ci sono, ma nessuna riga vuota: un codice che conta anche le righe vuote passa tutto | le_righe_vuote_sono_contate |
La prima trappola è quella che si scopre sempre troppo tardi: «da me funziona». I file di prova si scrivono sempre in tmp_path.