I bug silenziosi, esercizi spiegati
Cinque bug, dal test rosso alla correzione
- 20 minuti di lettura
Cinque esempi della centrale della Linea Menta. In ognuno c'è una funzione che gira senza errori e un test rosso. Il ritmo è sempre lo stesso:
- Prevedi: leggi il codice (o il test) e scrivi su un foglio cosa ti aspetti. Prima di aprire la risposta.
- In italiano: cosa succede, a parole.
- Passo per passo: la tabella giro per giro, con i valori presi dal debugger.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi rifare ogni esempio: crea un file con la funzione e uno con il test, e lancia pytest. I breakpoint si mettono come al solito, e Debug Test parte dal pannello Testing (la provetta di VS Code): trovi come si fa in Il debugger su FastAPI e nei test.
A · La media che arrotonda
Lucia Ferri vuole il ritardo medio dei treni della sera. Il programma di Marta Villa:
def ritardo_medio(ritardi):
return sum(ritardi) // len(ritardi)e tre test:
def test_quattro_treni():
assert ritardo_medio([2, 3, 4, 5]) == 3.5
def test_due_treni():
assert ritardo_medio([1, 2]) == 1.5
def test_un_treno_solo():
assert ritardo_medio([7]) == 7Prevedi. Quanti test sono rossi? E nelle righe E assert … == …, cosa c'è a sinistra?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
test_ritardo_medio.py::test_quattro_treni FAILED
test_ritardo_medio.py::test_due_treni FAILED
test_ritardo_medio.py::test_un_treno_solo PASSED> assert ritardo_medio([2, 3, 4, 5]) == 3.5
E assert 3 == 3.5
E + where 3 = ritardo_medio([2, 3, 4, 5])Due rossi e uno verde. A sinistra c'è quello che la funzione ha restituito: 3. A destra quello che il test voleva: 3.5.
Il comando e quello che stampa pytest, senza intestazione:
pytest test_ritardo_medio.py -v --no-header======================================= test session starts ========================================
collecting ... collected 3 items
test_ritardo_medio.py::test_quattro_treni FAILED [ 33%]
test_ritardo_medio.py::test_due_treni FAILED [ 66%]
test_ritardo_medio.py::test_un_treno_solo PASSED [100%]
============================================= FAILURES =============================================
________________________________________ test_quattro_treni ________________________________________
def test_quattro_treni():
> assert ritardo_medio([2, 3, 4, 5]) == 3.5
E assert 3 == 3.5
E + where 3 = ritardo_medio([2, 3, 4, 5])
test_ritardo_medio.py:5: AssertionError
__________________________________________ test_due_treni __________________________________________
def test_due_treni():
> assert ritardo_medio([1, 2]) == 1.5
E assert 1 == 1.5
E + where 1 = ritardo_medio([1, 2])
test_ritardo_medio.py:9: AssertionError
===================================== short test summary info ======================================
FAILED test_ritardo_medio.py::test_quattro_treni - assert 3 == 3.5
FAILED test_ritardo_medio.py::test_due_treni - assert 1 == 1.5
=================================== 2 failed, 1 passed in 0.01s ====================================In italiano. La somma è 14, i treni sono 4, la media vera è 3.5. La funzione dà 3: ha buttato via il .5. In tutti e due i test rossi il risultato è l'intero sotto quello atteso (3 invece di 3.5, 1 invece di 1.5): un indizio che qualcosa arrotonda per difetto. Il test con un treno solo è verde per caso: 7 diviso 1 non ha resto, e arrotondare non cambia niente.
Passo per passo. Questa volta basta una riga sola, la return. Un breakpoint lì, Debug Test su test_quattro_treni, e in WATCH due espressioni:
| Espressione | Cosa mostra | Prevedevo |
|---|---|---|
sum(ritardi) | 14 | 14 |
len(ritardi) | 4 | 4 |
sum(ritardi) / len(ritardi) | 3.5 | 3.5 |
sum(ritardi) // len(ritardi) | 3 | 3.5 |
La riga con // è quella che si separa dalla previsione. // è la divisione che butta via la parte dopo la virgola; / è quella che la tiene (si vedono tutte e due in Valori, tipi, etichette).
Cosa portiamo a casa. Il test rosso ti dice la direzione dell'errore (3 invece di 3.5, 1 invece di 1.5: sempre troppo poco, sempre per mezzo punto). Un test verde sullo stesso codice ([7]) non vuol dire niente: guarda sempre anche quelli che passano, per capire perché passano.
B · Il totale che resta all'ultimo
La centrale somma i passeggeri saliti in tre giri.
def saliti_totali(giri):
totale = 0
for saliti in giri:
totale = saliti
return totaledef test_i_saliti_di_tre_giri():
assert saliti_totali([30, 12, 8]) == 50Prevedi. Prima di lanciare, scrivi: cosa dovrebbe valere totale dopo ognuno dei tre giri? E quanto dirà il test a sinistra di ==?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Dopo i tre giri totale dovrebbe valere 30, poi 42, poi 50.
E assert 8 == 50
E + where 8 = saliti_totali([30, 12, 8])A sinistra c'è 8: l'ultimo numero della lista. Il test non dice altro.
Il test dà 8 == 50. Nessun traceback. Mettiamo un breakpoint sulla riga totale = saliti, Debug Test, e F5 a ogni giro. Il debugger si ferma prima della riga:
3 for saliti in giri:
●▶ 4 totale = saliti ← la riga gialla: non ancora eseguita
5 return totale
VARIABLES
totale = 30
saliti = 12È la seconda fermata. Tutte le fermate, prese dal debugger:
| Giro | saliti | totale prima della riga | Prevedevo dopo la riga | Vedo dopo la riga |
|---|---|---|---|---|
| 1 | 30 | 0 | 30 | 30 |
| 2 | 12 | 30 | 42 | 12 |
| 3 | 8 | 12 | 50 | 8 |
Il giro 1 non tradisce: 0 e 30 sono 30 in tutti e due i modi. Il giro 2 sì: prevedevo 42, e alla fermata del giro 3 totale vale 12, non 42. Il bug è nella riga appena eseguita.
Il disegno.
In italiano. totale = saliti dice: «totale diventa il numero di questo giro». Non lo somma a quello che c'era. Ogni giro cancella il lavoro del giro prima, e alla fine resta l'ultimo.
Cosa portiamo a casa. Il primo giro spesso non basta per accorgersi: i due codici danno lo stesso valore. Guarda il secondo. Il bug è nel passaggio da un giro al successivo.
C · Il bug non è dove il test ti manda
Il costo del biglietto, in centesimi. Il ridotto costa la metà.
LISTINO = {"urbana": 220, "extraurbana": 310}
def sconto_ridotto(prezzo):
return prezzo - 50
def costo_biglietto(zona, ridotto):
prezzo = LISTINO[zona]
if ridotto:
prezzo = sconto_ridotto(prezzo)
return prezzodef test_biglietto_intero():
assert costo_biglietto("urbana", False) == 220
def test_biglietto_ridotto_costa_la_meta():
assert costo_biglietto("urbana", True) == 110Prevedi. Il primo test passa o cade? Il secondo, cosa dice a sinistra di ==?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
test_costo_biglietto.py::test_biglietto_intero PASSED
test_costo_biglietto.py::test_biglietto_ridotto_costa_la_meta FAILED
E AssertionError: assert 170 == 110
E + where 170 = costo_biglietto('urbana', True)Il primo passa (l'if non si apre). Il secondo dà 170: 220 meno 50. Non è la metà.
Il test è caduto su costo_biglietto, ma la funzione ha solo quattro righe e sembrano tutte giuste. Metti un breakpoint sulla riga prezzo = sconto_ridotto(prezzo) e Debug Test:
9 prezzo = LISTINO[zona]
10 if ridotto:
●▶11 prezzo = sconto_ridotto(prezzo) ← non ancora eseguita
12 return prezzo
VARIABLES
zona = 'urbana'
ridotto = True
prezzo = 220Prevedi: dopo la riga, prezzo vale 110. Premi F10 (fn+F10 su Mac): la riga gira, e ti ritrovi sulla return:
VARIABLES
zona = 'urbana'
ridotto = True
prezzo = 170Previsione e osservazione si separano in questa riga. Ma la riga, scritta così, è giusta: chiama sconto_ridotto e prende quello che torna. Quello che sbaglia è la funzione che chiama. Rilancia, e questa volta, arrivato alla riga gialla, premi F11 (fn+F11, ↓ Step Into): il debugger entra nella funzione.
4 def sconto_ridotto(prezzo):
●▶ 5 return prezzo - 50 ← non ancora eseguita
VARIABLES
prezzo = 220Previsione: 220 diviso 2, cioè 110. La riga fa 220 meno 50. Eccolo.
In italiano. Il ridotto dovrebbe costare la metà; il programma toglie sempre 50 centesimi. Con 220 il risultato è 170, con 310 sarebbe 260.
Il disegno.
La correzione, con il suo commento:
def sconto_ridotto(prezzo):
# BUG: il ridotto sottrae 50 centesimi invece di dimezzare il prezzo: 220 diventa 170, non 110.
return prezzo // 2Qui // è giusto: i centesimi sono numeri interi, e metà di 220 è 110 (per un prezzo dispari, il centesimo in più sparisce: se la centrale non lo vuole è un'altra decisione, non è questo bug). Rilancia tutti i test:
test_costo_biglietto.py::test_biglietto_intero PASSED [ 50%]
test_costo_biglietto.py::test_biglietto_ridotto_costa_la_meta PASSED [100%]Cosa portiamo a casa. Il test cade su una funzione, ma il bug può stare in una che quella chiama. Quando la riga sembra giusta e il valore dopo è sbagliato, F11: entra. Lo vedi nel CALL STACK: una riga in più.
D · Il commento prima della correzione
La lista dei codici dei treni, in ordine.
def codici_in_ordine(codici):
ordinati = codici.sort()
return ordinatidef test_i_codici_in_ordine():
assert codici_in_ordine(["M16", "M12", "T28"]) == ["M12", "M16", "T28"]Prevedi. Cosa c'è a sinistra di ==? (Non è una lista.)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
E AssertionError: assert None == ['M12', 'M16', 'T28']
E + where None = codici_in_ordine(['M12', 'M16', 'T28'])A sinistra c'è None. E nota la seconda riga: la lista, dentro la chiamata, è già ordinata ('M12', 'M16', 'T28') anche se il test l'aveva passata in disordine.
.sort() ordina la lista sul posto: cambia quella che hai e non restituisce niente (cioè None). Quindi ordinati è None, e return ordinati restituisce None. Nel debugger, dopo la prima riga:
Ora il metodo. Prima il commento, sopra la riga sbagliata, con cosa hai visto e perché è sbagliato:
def codici_in_ordine(codici):
# BUG: sort() ordina la lista sul posto e restituisce None: ordinati vale None, non la lista ordinata.
ordinati = codici.sort()
return ordinatiSolo poi la correzione, la più piccola che spiega il commento: sorted(codici) restituisce una lista nuova, già ordinata.
def codici_in_ordine(codici):
# BUG: sort() ordina la lista sul posto e restituisce None: ordinati vale None, non la lista ordinata.
# sorted() restituisce una lista nuova, già ordinata.
ordinati = sorted(codici)
return ordinatitest_codici_in_ordine.py::test_i_codici_in_ordine PASSED [100%]In italiano. Il commento si legge come una frase: ho visto ordinati che vale None; è sbagliato perché sort() non restituisce la lista. Se riesci a scriverla, hai trovato il bug. Se per scriverla ti serve cercare, non l'hai ancora trovato.
Cosa portiamo a casa. Il commento viene prima. È la prova che hai capito, e resta nel codice per chi leggerà dopo di te. Il minimo da correggere qui era una parola: .sort() diventa sorted(), con il suo argomento.
E · La correzione che fa il furbo
Torniamo alla media dell'esempio A. Un collega ha fretta: il test dei quattro treni è rosso, e lo "sistema" così:
def ritardo_medio(ritardi):
if len(ritardi) == 4:
return 3.5
return sum(ritardi) // len(ritardi)Prevedi. Lanciando tutti e tre i test, quanti sono verdi?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Due. Il test dei quattro treni passa, perché ha quattro numeri. [7] passa come prima. Quello dei due treni è ancora rosso.
test_ritardo_medio.py::test_quattro_treni PASSED [ 33%]
test_ritardo_medio.py::test_due_treni FAILED [ 66%]
test_ritardo_medio.py::test_un_treno_solo PASSED [100%]E assert 1 == 1.5
E + where 1 = ritardo_medio([1, 2])Il bug non è sparito: il collega ha messo un if che riconosce il caso del test. Un caso diverso ([1, 2]) cade nello stesso buco di prima. E se avesse lanciato solo il primo test, sarebbe andato in produzione convinto di aver finito.
La strada giusta è quella dell'esempio A: il commento, e la correzione minima.
def ritardo_medio(ritardi):
# BUG: // arrotonda per difetto: 14 // 4 dà 3, non 3.5. Per la media serve la divisione vera, /.
return sum(ritardi) / len(ritardi)test_ritardo_medio.py::test_quattro_treni PASSED [ 33%]
test_ritardo_medio.py::test_due_treni PASSED [ 66%]
test_ritardo_medio.py::test_un_treno_solo PASSED [100%]In italiano. La correzione furba cambia la risposta per quel test. La correzione giusta cambia la regola per tutti.
Cosa portiamo a casa. Tre segnali di una correzione che fa il furbo: un if con un valore che compare nel test; un numero scritto a mano nel return; una riga che toglie il confronto invece di renderlo giusto. Il rimedio è sempre lo stesso: rilancia tutti i test, e chiediti se la tua riga spiega il commento che hai scritto.