Vai al contenuto
code-to-code

Apro l'indice…

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

HTTP e API4. Il primo serverp. 103

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.

http-primo-server-soluzioni.zip10 KB

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.

Python
@app.get("/")
def benvenuto():
    return {"officina": "Deposito della Linea Menta", "messaggio": "Benvenuto in officina"}

Dal vivo, con fastapi dev palestra/lavagna.py acceso:

Terminale
curl -s http://127.0.0.1:8000/
{"officina":"Deposito della Linea Menta","messaggio":"Benvenuto in officina"}

Le trappole.

Il codice sbagliatoCosa succedeIl 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 501test_l_indirizzo_principale_risponde, test_il_saluto_della_lavagna
print({...}) al posto di returnIl 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.

  1. Tutto l'elenco: restituisco la lista da_riparare così com'è. Una lista Python diventa una lista JSON.
  2. La prossima: restituisco il primo elemento della lista, quello in posizione 0. È un dizionario, e diventa un oggetto JSON.
Python
@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:

Terminale
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 sbagliatoCosa succedeIl test rosso
return {"riparazioni": da_riparare}La lista finisce dentro un oggetto: il client riceve {"riparazioni":[...]} invece di una listatest_tutte_le_riparazioni, test_la_rotta_legge_la_lista
return [...] con le tre riparazioni ricopiate a manoOggi va, ma quando la lista cambia la rotta risponde ancora con la vecchia copiatest_la_rotta_legge_la_lista
return da_riparare[1]La posizione 1 è la seconda: risponde M16 invece di T09test_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.

  1. Costruisco un dizionario nuovo, con le quattro chiavi della risposta.
  2. Ogni valore lo prendo da oggi: il manutentore, l'aiutante, l'ora d'inizio e quella di fine.
  3. da_solo è la domanda «l'aiutante è None?»: la sua risposta è già True o False.
  4. Lo restituisco. Il JSON lo fa FastAPI.
Python
@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:

ChiaveSi scriveOggiNel pomeriggio
di_turnooggi["manutentore"]"Ivo Brambati""Dario Sala"
aiutanteoggi["aiutante"]None, nel JSON null"Ivo Brambati"
da_solooggi["aiutante"] is NoneTrue, nel JSON trueFalse, 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:

Terminale
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 sbagliatoCosa succedeIl test rosso
return {"di_turno": "Ivo Brambati", "aiutante": null, "da_solo": true, "orario": [6, 14]}, il JSON del commento copiato nel filePer Python null e true sono nomi che nessuno ha definito: NameError: name 'null' is not defined. Dal vivo è un 500test_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 Ivotest_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 JSONtest_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.

  1. 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.
  2. Il conteggio: quanti attrezzi diversi sono quante chiavi ha l'armadio; i pezzi in tutto sono la somma dei valori.
  3. Tutte e due le rotte sono GET: il decoratore è @app.get, con il percorso del commento.
Python
@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.

inizio GET /attrezzi/mancanti mancanti = [] per ogni attrezzo, pezzi in armadio.items() se pezzi == 0 sì: mancanti.append(attrezzo) restituisci mancantiGET /attrezzi/mancantimancanti = []per ogni attrezzo, pezzi inarmadio.items()pezzi == 0mancanti.append(attrezzo)restituisci mancantinosìfiniti
Gli attrezzi che mancano

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:

Giroattrezzopezzipezzi == 0?mancanti dopo il giro
prima———[]
1"chiave inglese"3no[]
2"trapano"1no[]
3"saldatrice"0sì["saldatrice"]
4"multimetro"2no["saldatrice"]
5"cric"0sì["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:

Terminale
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 sbagliatoCosa succedeIl test rosso
Il def senza il decoratore sopraUna funzione normale, che nessuno collega a niente: GET /attrezzi/mancanti risponde 404 Not Foundtest_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio, test_mancanti_si_legge_soltanto
@app.get("attrezzi/mancanti"), senza la barra all'inizioFastAPI accetta il percorso senza protestare, ma nessuna richiesta lo raggiunge: ogni percorso vero comincia con /. Di nuovo 404test_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 405test_gli_attrezzi_mancanti, test_mancanti_con_un_altro_armadio, test_mancanti_si_legge_soltanto
Il return mancanti dentro il forLa 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.