Il primo server, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i due più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano qualche test e si rompono su un altro.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
Una cosa vale per i primi tre esercizi: tolta la riga del 501, HTTPException non serve più. Nelle soluzioni l'import è diventato from fastapi import FastAPI. Se lo lasci, funziona lo stesso: VS Code lo mostra solo sbiadito, come una cosa che non usi.
1 · La lavagna dell'officina
In italiano. Quando qualcuno chiede GET /, la funzione restituisce il dizionario del saluto. FastAPI lo trasforma in JSON.
@app.get("/")
def benvenuto():
return {"officina": "Deposito della Linea Menta", "messaggio": "Benvenuto in officina"}Dal vivo, con fastapi dev palestra/lavagna.py acceso:
curl -s http://127.0.0.1:8000/{"officina":"Deposito della Linea Menta","messaggio":"Benvenuto in officina"}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il return scritto sotto la riga del 501, che è rimasta lì | Il raise ferma la funzione per primo: il return non arriva mai, e la rotta risponde ancora 501 | test_l_indirizzo_principale_risponde, test_il_saluto_della_lavagna |
print({...}) al posto di return | Il dizionario finisce nel terminale del server; il client riceve null. Il codice è 200, il corpo no: assert None == {...} | test_il_saluto_della_lavagna |
return "Benvenuto in officina" | Una stringa diventa una stringa JSON, non un oggetto: assert 'Benvenuto in officina' == {...} | test_il_saluto_della_lavagna |
La seconda è la più insidiosa: il primo test è verde, perché il server risponde 200. Il codice dice solo che non si è rotto niente, non che la risposta è giusta.
2 · Cosa c'è da riparare
In italiano.
- Tutto l'elenco: restituisco la lista
da_ripararecosì com'è. Una lista Python diventa una lista JSON. - La prossima: restituisco il primo elemento della lista, quello in posizione 0. È un dizionario, e diventa un oggetto JSON.
@app.get("/riparazioni")
def lista_riparazioni():
return da_riparare
@app.get("/riparazioni/prossima")
def prossima_riparazione():
return da_riparare[0]Dal vivo, con fastapi dev palestra/riparazioni.py acceso:
curl -s http://127.0.0.1:8000/riparazioni
curl -s http://127.0.0.1:8000/riparazioni/prossima[{"treno":"T09","guasto":"porte bloccate"},{"treno":"M16","guasto":"freno del vagone 3"},{"treno":"M14","guasto":"luce spenta nel vagone 2"}]{"treno":"T09","guasto":"porte bloccate"}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return {"riparazioni": da_riparare} | La lista finisce dentro un oggetto: il client riceve {"riparazioni":[...]} invece di una lista | test_tutte_le_riparazioni, test_la_rotta_legge_la_lista |
return [...] con le tre riparazioni ricopiate a mano | Oggi va, ma quando la lista cambia la rotta risponde ancora con la vecchia copia | test_la_rotta_legge_la_lista |
return da_riparare[1] | La posizione 1 è la seconda: risponde M16 invece di T09 | test_la_prossima_riparazione, test_la_prossima_e_la_prima_della_lista |
Ecco la prima trappola dal vivo, con curl:
{"riparazioni":[{"treno":"T09","guasto":"porte bloccate"},{"treno":"M16","guasto":"freno del vagone 3"},{"treno":"M14","guasto":"luce spenta nel vagone 2"}]}Non è un errore di FastAPI: è un'altra risposta. Il client che aspetta una lista e riceve un oggetto si rompe dall'altra parte.
3 · Il turno di oggi
In italiano.
- Costruisco un dizionario nuovo, con le quattro chiavi della risposta.
- Ogni valore lo prendo da
oggi: il manutentore, l'aiutante, l'ora d'inizio e quella di fine. da_soloè la domanda «l'aiutante èNone?»: la sua risposta è giàTrueoFalse.- Lo restituisco. Il JSON lo fa FastAPI.
@app.get("/turno")
def riassunto_turno():
return {
"di_turno": oggi["manutentore"],
"aiutante": oggi["aiutante"],
"da_solo": oggi["aiutante"] is None,
"orario": (oggi["dalle"], oggi["alle"]),
}Va bene anche [oggi["dalle"], oggi["alle"]] con le quadre: nel JSON una lista e una tupla arrivano uguali. E va bene un if per da_solo, con True in un ramo e False nell'altro: è più lungo, ma dice la stessa cosa.
Passo per passo, chiave per chiave, con il turno di oggi e con quello del pomeriggio del test:
| Chiave | Si scrive | Oggi | Nel pomeriggio |
|---|---|---|---|
di_turno | oggi["manutentore"] | "Ivo Brambati" | "Dario Sala" |
aiutante | oggi["aiutante"] | None, nel JSON null | "Ivo Brambati" |
da_solo | oggi["aiutante"] is None | True, nel JSON true | False, nel JSON false |
orario | (oggi["dalle"], oggi["alle"]) | (6, 14), nel JSON [6,14] | (14, 22), nel JSON [14,22] |
Dal vivo, con fastapi dev palestra/turno.py acceso:
curl -s http://127.0.0.1:8000/turno{"di_turno":"Ivo Brambati","aiutante":null,"da_solo":true,"orario":[6,14]}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return {"di_turno": "Ivo Brambati", "aiutante": null, "da_solo": true, "orario": [6, 14]}, il JSON del commento copiato nel file | Per Python null e true sono nomi che nessuno ha definito: NameError: name 'null' is not defined. Dal vivo è un 500 | test_il_turno_di_oggi, test_nel_testo_ci_sono_null_e_true, test_il_turno_del_pomeriggio |
return {"di_turno": "Ivo Brambati", "aiutante": None, "da_solo": True, "orario": (6, 14)} | Python giusto, ma scritto a mano: con il turno del pomeriggio risponde ancora Ivo | test_il_turno_del_pomeriggio |
return json.dumps(riassunto) | Il JSON fatto due volte: tu trasformi il dizionario in una stringa, FastAPI trasforma la stringa in JSON | test_il_turno_di_oggi, test_nel_testo_ci_sono_null_e_true, test_il_turno_del_pomeriggio |
La terza, dal vivo con curl:
"{\"di_turno\": \"Ivo Brambati\", \"aiutante\": null, \"da_solo\": true, \"orario\": [6, 14]}"Tutta la risposta è una stringa sola, tra virgolette, con le virgolette di dentro scritte \". Chi la riceve non trova nessuna chiave: deve decifrarla due volte. Restituisci il dizionario, e basta.
4 · L'armadio degli attrezzi
In italiano.
- Gli attrezzi che mancano: parto da una lista vuota; per ogni attrezzo dell'armadio, con i suoi pezzi, se i pezzi sono zero lo aggiungo alla lista. Alla fine, dopo il
for, restituisco la lista. - Il conteggio: quanti attrezzi diversi sono quante chiavi ha l'armadio; i pezzi in tutto sono la somma dei valori.
- Tutte e due le rotte sono GET: il decoratore è
@app.get, con il percorso del commento.
@app.get("/attrezzi/mancanti")
def attrezzi_mancanti():
mancanti = []
for attrezzo, pezzi in armadio.items():
if pezzi == 0:
mancanti.append(attrezzo)
return mancanti
@app.get("/attrezzi/conteggio")
def conteggio_attrezzi():
return {"attrezzi": len(armadio), "pezzi": sum(armadio.values())}Il disegno.
Il nome della seconda funzione lo sceglievi tu: i test guardano solo il verbo, il percorso e la risposta. In /docs il nome diventa il titolo della rotta: «Conteggio Attrezzi».
Passo per passo, il setaccio sull'armadio:
| Giro | attrezzo | pezzi | pezzi == 0? | mancanti dopo il giro |
|---|---|---|---|---|
| prima | — | — | — | [] |
| 1 | "chiave inglese" | 3 | no | [] |
| 2 | "trapano" | 1 | no | [] |
| 3 | "saldatrice" | 0 | sì | ["saldatrice"] |
| 4 | "multimetro" | 2 | no | ["saldatrice"] |
| 5 | "cric" | 0 | sì | ["saldatrice", "cric"] |
E il conteggio: le chiavi sono 5; i valori sono 3, 1, 0, 2, 0, e la loro somma fa 6.
Dal vivo, con fastapi dev palestra/attrezzi.py acceso:
curl -s http://127.0.0.1:8000/attrezzi/mancanti
curl -s http://127.0.0.1:8000/attrezzi/conteggio["saldatrice","cric"]{"attrezzi":5,"pezzi":6}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il def senza il decoratore sopra | Una funzione normale, che nessuno collega a niente: GET /attrezzi/mancanti risponde 404 Not Found | test_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio, test_mancanti_si_legge_soltanto |
@app.get("attrezzi/mancanti"), senza la barra all'inizio | FastAPI accetta il percorso senza protestare, ma nessuna richiesta lo raggiunge: ogni percorso vero comincia con /. Di nuovo 404 | test_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio, test_mancanti_si_legge_soltanto |
@app.post("/attrezzi/mancanti") | La rotta c'è, ma per POST: la GET riceve 405, e la POST risponde 200 invece di 405 | test_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio, test_mancanti_si_legge_soltanto |
Il return mancanti dentro il for | La funzione esce al primo giro: con l'armadio di Ivo, [] | test_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio |
sum(armadio) | Il sum su un dizionario gira sulle chiavi, che sono testi: TypeError: unsupported operand type(s) for +: 'int' and 'str' | test_il_conteggio, test_conteggio_con_un_altro_armadio |
Le prime tre fanno diventare rossi gli stessi tre test, ma con due numeri diversi nel messaggio: leggili, e sai già dove guardare. assert 404 == 200: la rotta non c'è (manca il decoratore, o il percorso è scritto diverso). assert 405 == 200: la rotta c'è, con il verbo sbagliato.