Vai al contenuto
code-to-code

Apro l'indice…

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

Errori e debugger6. Il debugger su FastAPI e nei testp. 140

Il debugger su FastAPI e nei test, esercizi spiegati

Quattro esempi, dalla configurazione al test rosso

  • 20 minuti di lettura

Quattro esempi, uno per cosa nuova del capitolo. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi, e scrivi su un foglio cosa succede. Prima di aprire la risposta.
  2. In italiano: cosa succede, a parole.
  3. Passo per passo: cosa vedi in VS Code a ogni mossa.
  4. Cosa portiamo a casa: la cosa da ricordare.

Gli esempi non hanno uno zip: i valori e gli output sono quelli veri di un server acceso e di un test lanciato davvero. Se vuoi provarli, copia il codice in una cartella tua e segui lo stesso ordine.


A · La configurazione, pezzo per pezzo

La biglietteria di Porta Codice ha una sua API, in servizi/biglietti/main.py. La cartella aperta in VS Code è linea-menta, quella sopra servizi.

linea-menta/
├── .vscode/launch.json
└── servizi/
    └── biglietti/
        └── main.py        ← dentro: app = FastAPI()

Tre configurazioni, tre args.

JSON
"args": ["main:app", "--app-dir", "servizi/biglietti"]
JSON
"args": ["main:app"]
JSON
"args": ["main:app", "--app-dir", "servizi"]
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Quale delle tre accende il server? E per le altre, che errore dà uvicorn?

Prima configurazione:

INFO:     Started server process [1133]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

Seconda e terza, identiche:

ERROR:    Error loading ASGI app. Could not import module "main".
  • La prima dice dove sta main.py: servizi/biglietti, a partire dalla cartella aperta.
  • La seconda non dice niente: uvicorn guarda in linea-menta, e lì main.py non c'è.
  • La terza guarda in servizi, che è una cartella sopra: main.py sta dentro biglietti, un gradino più in giù. Un percorso quasi giusto sbaglia come uno sbagliato del tutto.

In italiano. --app-dir è l'indirizzo della cartella che contiene main.py, scritto partendo da quella aperta in VS Code. Né un gradino più in su, né uno più in giù: proprio quella.

Passo per passo. Come controllare la tua configurazione senza aspettare VS Code:

  1. Prendi gli args e toglili dalle virgolette: main:app --app-dir servizi/biglietti.
  2. Mettici davanti python -m uvicorn.
  3. Lancialo nel terminale, dalla cartella aperta in VS Code:
Terminale
python -m uvicorn main:app --app-dir servizi/biglietti

Se nel terminale parte, parte anche con il debugger. Se non parte, l'errore è lo stesso che vedrebbe VS Code, ma scritto dove lo leggi meglio.

Altre due righe che capitano, entrambe vere:

Terminale
python -m uvicorn --app-dir servizi/biglietti
Usage: python -m uvicorn [OPTIONS] APP
Try 'python -m uvicorn --help' for help.

Error: Missing argument 'APP'.

Manca main:app: l'app da accendere.

Terminale
python -m uvicorn main:applicazione --app-dir servizi/biglietti
ERROR:    Error loading ASGI app. Attribute "applicazione" not found in module "main".

Il file lo trova, ma dentro non c'è nessuna variabile applicazione: dopo i due punti ci va il nome della variabile con FastAPI(), qui app.

Cosa portiamo a casa. Could not import module "main" vuol dire quasi sempre --app-dir: manca, o punta alla cartella sbagliata. Prima di toccare il codice, prova gli args nel terminale.


B · Il breakpoint che scatta tre volte, o mai

Il tabellone di Piazza Query ha una rotta che costruisce le righe da mostrare, un treno alla volta.

Python
ARRIVI = {
    "Piazza Query": ["M12", "M14", "T28"],
    "Vecchia Fiera": [],
}


@app.get("/tabellone/{stazione}")
def tabellone(stazione: str):
    treni = ARRIVI.get(stazione, [])
    righe = []
    for treno in treni:
        riga = f"{treno} in arrivo"       # ← il pallino rosso è qui
        righe.append(riga)
    return {"stazione": stazione, "righe": righe}

Il server è acceso dal debugger. Da /docs fai prima GET /tabellone/{stazione} con Piazza Query → Execute, poi con Vecchia Fiera → Execute.

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Per ciascuna richiesta: quante volte si ferma il server sul pallino? E con Piazza Query, quanto vale righe alla terza fermata?

Piazza Query: tre fermate, una per treno. Vecchia Fiera: nessuna: /docs risponde subito, senza fermarsi.

Alla terza fermata righe vale ['M12 in arrivo', 'M14 in arrivo']: ha solo i due treni già passati, perché la riga gialla non ha ancora costruito quella di T28.

Il disegno. Le variabili alla terza fermata:

ARRIVI = {"Piazza Query": ["M12", "M14", "T28"], "Vecchia Fiera": []} treni = ARRIVI["Piazza Query"] righe = ["M12 in arrivo", "M14 in arrivo"] treno = "T28" riga = "M14 in arrivo"ARRIVItrenirighetrenorigadict"Piazza Query""Vecchia Fiera"list"M12"0"M14"1"T28"2listlist"M12 in arrivo"0"M14 in arrivo"1str"T28"str"M14 in arrivo"
VARIABLES alla terza fermata, con Piazza Query

In italiano. Il pallino sta dentro il for. Ogni giro del for ci passa una volta, e ogni volta il server si ferma. Con Vecchia Fiera la lista dei treni è vuota: il for non fa nessun giro, e il pallino non lo vede mai.

Il disegno.

inizio GET /tabellone/{stazione} treni = ARRIVI.get(stazione, []) righe = [] per ogni treno in treni passo riga = f"{treno} in arrivo" passo righe.append(riga) restituisci stazione e righeGET /tabellone/{stazione}treni = ARRIVI.get(stazione,[])righe = []per ogni treno in treniriga = f"{treno} in arrivo"righe.append(riga)restituisci stazione e righefiniti
La rotta e il suo pallino

Passo per passo. Con Piazza Query, /docs gira e VS Code è fermo. A ogni ▶ Continue · F5 (su Mac fn+F5) il server va avanti fino alla fermata dopo:

Fermatatrenorigarighe
1'M12'non esiste ancora[]
2'M14''M12 in arrivo'['M12 in arrivo']
3'T28''M14 in arrivo'['M12 in arrivo', 'M14 in arrivo']

Guarda la colonna riga: alla fermata 2 c'è ancora il valore del giro prima. La riga gialla non è stata eseguita, quindi riga non è stata ancora rifatta. Dopo la terza fermata premi ancora Continue: nessun'altra fermata, e finalmente il browser riceve la risposta.

JSON
{"stazione": "Piazza Query", "righe": ["M12 in arrivo", "M14 in arrivo", "T28 in arrivo"]}

Cosa portiamo a casa. Il numero di fermate è il numero di volte in cui la richiesta passa da quella riga. E per una richiesta il browser aspetta fino all'ultima fermata: /docs non risponde finché non hai premuto Continue abbastanza volte.


C · Ho cambiato il codice, ma risponde come prima

Il server delle stazioni è acceso (senza --reload). Chiedi una stazione che non c'è:

Terminale
curl -s "http://127.0.0.1:8000/stazioni/Piazza%20Luna/affollamento"
{"detail":"Stazione non trovata"}

In main.py cambi il testo del 404 in "Stazione sconosciuta" e salvi. Rifai la stessa richiesta.

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Cosa risponde il server dopo il salvataggio?

{"detail":"Stazione non trovata"}

Lo stesso di prima. Il file sul disco è cambiato, ma il server ha ancora in memoria la versione vecchia.

In italiano. Python legge main.py una volta sola, quando il server parte, e da quel momento usa la copia in memoria. Con --reload uvicorn si accorgerebbe del salvataggio e ripartirebbe da solo. Senza, devi dirglielo tu.

Passo per passo.

  1. Salvi il file. Il server non lo sa.
  2. Premi ↻ Restart · Cmd+Shift+F5 (Windows: Ctrl+Shift+F5), nella barra del debugger. Il server si spegne e riparte, leggendo il file di nuovo.
  3. Rifai la richiesta:
{"detail":"Stazione sconosciuta"}

Il testo nuovo. I breakpoint sono rimasti al loro posto.

Cosa portiamo a casa. «Ho corretto ma risponde come prima» vuol dire quasi sempre: non hai fatto il Restart. Salva, ↻, poi riprova.


D · Il test rosso, e il debugger dentro il test

Le stazioni hanno una rotta che dice a che punto è l'affollamento, in percentuale. Il codice sembra giusto.

Python
STAZIONI = {
    "Porta Codice": {"presenti": 150, "capienza": 200},
    "Largo Lista": {"presenti": 90, "capienza": 120},
    "Ponte Ciclo": {"presenti": 40, "capienza": 160},
}


def percentuale(presenti: int, capienza: int) -> int:
    return presenti // capienza * 100


@app.get("/stazioni/{nome}/affollamento")
def affollamento(nome: str):
    stazione = STAZIONI.get(nome)
    if stazione is None:
        raise HTTPException(status_code=404, detail="Stazione non trovata")
    presenti = stazione["presenti"]
    capienza = stazione["capienza"]
    piena = percentuale(presenti, capienza)
    return {"stazione": nome, "presenti": presenti, "percentuale": piena}

C'è un test: Porta Codice ha 150 persone su 200 posti, quindi il 75 per cento.

Terminale
pytest servizi/stazioni/test_main.py -q
F.                                                                                           [100%]
============================================= FAILURES =============================================
_______________________________ test_porta_codice_e_al_75_per_cento ________________________________

    def test_porta_codice_e_al_75_per_cento():
>       assert client.get("/stazioni/Porta Codice/affollamento").json() == {
            "stazione": "Porta Codice",
            "presenti": 150,
            "percentuale": 75,
        }
E       AssertionError: assert {'stazione': ...rcentuale': 0} == {'stazione': ...centuale': 75}
E         
E         Omitting 2 identical items, use -vv to show
E         Differing items:
E         {'percentuale': 0} != {'percentuale': 75}
E         Use -v to get more diff

servizi/stazioni/test_main.py:9: AssertionError
===================================== short test summary info ======================================
FAILED servizi/stazioni/test_main.py::test_porta_codice_e_al_75_per_cento - AssertionError: asser...
1 failed, 1 passed in 0.21s

Nessun traceback del tuo codice: il programma non si è rotto, ha risposto 0 invece di 75. È il caso in cui si va a guardare dentro.

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Metti il pallino sulla riga return presenti // capienza * 100 e lancia Debug Test sul test rosso. Quando si ferma, cosa vedi in VARIABLES? E dopo, cosa vale piena?

In VARIABLES, alla fermata: presenti = 150, capienza = 200. I due numeri sono giusti. Poi, con ↷ Step Over (F10), il server torna alla rotta, e un altro F10 dopo, piena = 0.

Il disegno. Le variabili della rotta, appena prima di chiamare percentuale:

STAZIONI = { "Porta Codice": {"presenti": 150, "capienza": 200}, "Largo Lista": {"presenti": 90, "capienza": 120}, "Ponte Ciclo": {"presenti": 40, "capienza": 160}, } nome = "Porta Codice" stazione = STAZIONI["Porta Codice"] presenti = 150 capienza = 200STAZIONInomestazionepresenticapienzadict"Porta Codice""Largo Lista""Ponte Ciclo"dict"presenti"150"capienza"200dict"presenti"90"capienza"120dict"presenti"40"capienza"160str"Porta Codice"int150int200
VARIABLES nella rotta, prima della chiamata a percentuale

In italiano. I numeri in ingresso sono giusti, il risultato no: l'errore sta nell'operazione. Prima di premere F10 ti dici cosa ti aspetti (150 su 200 fa il 75), poi guardi cosa esce (0), e dove le due cose si separano c'è il bug.

Passo per passo.

  1. Pallino rosso sulla riga 13 di main.py (dentro percentuale, non nel test).
  2. Pannello Testing (la provetta) → tasto destro sul test rosso → Debug Test.
  3. Il test parte, chiama la rotta, la rotta chiama percentuale, e ti fermi sul pallino. Il browser non c'entra: non c'è nessun server.
  4. VARIABLES: presenti = 150, capienza = 200. CALL STACK: in cima percentuale, sotto affollamento. Clicca su affollamento: VARIABLES mostra nome = 'Porta Codice', stazione = ..., e piena non c'è ancora.
  5. Torna in cima, F10 due volte: piena = 0.

Ora l'operazione. Python fa 150 // 200 prima di moltiplicare: la divisione intera di 150 per 200 dà 0, e 0 * 100 resta 0. Per avere il 75 si moltiplica prima: 150 * 100 // 200.

Prima di toccare la riga, si scrive sopra il perché. Poi si corregge:

Python
def percentuale(presenti: int, capienza: int) -> int:
    # BUG: 150 // 200 fa 0 e poi 0 * 100 resta 0: moltiplico prima di dividere.
    return presenti * 100 // capienza
..                                                                                           [100%]
2 passed in 0.15s

Cosa portiamo a casa. Debug Test serve quando c'è un test rosso e nessun errore da leggere: il pallino dentro il codice che il test chiama, poi i valori in VARIABLES. Il commento # BUG: prima della correzione, e solo allora la riga nuova. Come si ragiona in generale sui bug che non danno errori lo trovi in I bug silenziosi.