Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Errori e debugger7. I bug silenziosip. 161

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:

  1. Prevedi: leggi il codice (o il test) e scrivi su un foglio cosa ti aspetti. Prima di aprire la risposta.
  2. In italiano: cosa succede, a parole.
  3. Passo per passo: la tabella giro per giro, con i valori presi dal debugger.
  4. 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:

Python
def ritardo_medio(ritardi):
    return sum(ritardi) // len(ritardi)

e tre test:

Python
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]) == 7

Prevedi. 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:

Terminale
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:

EspressioneCosa mostraPrevedevo
sum(ritardi)1414
len(ritardi)44
sum(ritardi) / len(ritardi)3.53.5
sum(ritardi) // len(ritardi)33.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.

Python
def saliti_totali(giri):
    totale = 0
    for saliti in giri:
        totale = saliti
    return totale
Python
def test_i_saliti_di_tre_giri():
    assert saliti_totali([30, 12, 8]) == 50

Prevedi. 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:

Girosalititotale prima della rigaPrevedevo dopo la rigaVedo dopo la riga
13003030
212304212
3812508

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.

inizio pallino su totale = saliti finché ci sono giri passo F5: il debugger si ferma passo guardo totale e saliti se totale non è quello previsto sì: fine il bug è nella riga appena eseguitapallino su totale = salitici sono giriF5: il debugger si fermaguardo totale e salititotale non è quelloprevistoil bug è nella riga appenaeseguitasìnosìno
La caccia al giro sbagliato

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à.

Python
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 prezzo
Python
def test_biglietto_intero():
    assert costo_biglietto("urbana", False) == 220


def test_biglietto_ridotto_costa_la_meta():
    assert costo_biglietto("urbana", True) == 110

Prevedi. 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 = 220

Prevedi: 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 = 170

Previsione 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 = 220

Previsione: 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.

inizio costo_biglietto(zona, ridotto) prezzo = LISTINO[zona] se ridotto sì: prezzo = sconto_ridotto(prezzo) restituisci prezzocosto_biglietto(zona,ridotto)prezzo = LISTINO[zona]ridottoprezzo =sconto_ridotto(prezzo)restituisci prezzonosì
Il costo del biglietto

La correzione, con il suo commento:

Python
def sconto_ridotto(prezzo):
    # BUG: il ridotto sottrae 50 centesimi invece di dimezzare il prezzo: 220 diventa 170, non 110.
    return prezzo // 2

Qui // è 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.

Python
def codici_in_ordine(codici):
    ordinati = codici.sort()
    return ordinati
Python
def 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:

codici = ["M12", "M16", "T28"] ordinati = Nonecodiciordinatilist"M12"0"M16"1"T28"2NoneTypeNone
VARIABLES dopo la prima riga

Ora il metodo. Prima il commento, sopra la riga sbagliata, con cosa hai visto e perché è sbagliato:

Python
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 ordinati

Solo poi la correzione, la più piccola che spiega il commento: sorted(codici) restituisce una lista nuova, già ordinata.

Python
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 ordinati
test_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ì:

Python
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.

Python
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.