Fare richieste, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i 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.
Tutte e sei le funzioni hanno lo stesso scheletro, ed è il succo del capitolo:
- La richiesta: il verbo, il percorso, e quello che serve (
params=,json=,headers=). - Il codice:
risposta.status_code, prima di tutto il resto. - Il corpo:
risposta.json(), e da lì le chiavi che ti servono.
1 · Gli orari sul tablet
In italiano.
- Chiedo a InfoMenta le partenze, con la stazione nella query.
- Parto da una lista vuota.
- Per ogni partenza del JSON, aggiungo «ora treno».
- Alla fine restituisco la lista.
def orari_di(client: httpx.Client, stazione_id: int) -> list[str]:
risposta = client.get("/partenze", params={"stazione_id": stazione_id})
orari = []
for partenza in risposta.json():
orari.append(f"{partenza['ora']} {partenza['treno']}")
return orariDentro la f-string le chiavi sono tra apici singoli, partenza['ora']: la f-string è già tra virgolette doppie.
Dal vivo, con InfoMenta accesa:
python3 palestra/orari.py['05:42 M12', '05:54 M14', '06:06 M12']Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
client.get("/partenze"), senza params | InfoMenta risponde con tutte e sei le partenze della linea: Ponte Ciclo si ritrova anche quelle di Porta Codice | test_le_partenze_di_porta_codice, test_le_partenze_di_ponte_ciclo, test_una_stazione_senza_partenze |
client.get("/partenze?stazione_id=" + stazione_id) | stazione_id è un numero, e un testo più un numero non si fa: TypeError: can only concatenate str (not "int") to str | tutti e tre |
return orari dentro il for | Esce al primo giro: una partenza sola. E da Vecchia Fiera il for non gira mai, la funzione arriva in fondo senza return e dà None | test_le_partenze_di_porta_codice, test_una_stazione_senza_partenze |
La query scritta a mano si può fare, con una f-string: client.get(f"/partenze?stazione_id={stazione_id}") passa i test. Ma con due o tre filtri diventa illeggibile, e params= pensa lui a ?, = e &.
2 · Che treno è il numero 5?
In italiano.
- Chiedo a InfoMenta il treno, con l'id nel percorso.
- Se il codice è 404, il treno non c'è:
None. - Altrimenti leggo il JSON, un dizionario, e restituisco il suo codice.
def codice_del_treno(client: httpx.Client, treno_id: int) -> str | None:
risposta = client.get(f"/treni/{treno_id}")
if risposta.status_code == 404:
return None
treno = risposta.json()
return treno["codice"]python3 palestra/codice_treno.pyT09
NoneNel terminale del server si vedono le due richieste, una per codice:
INFO: 127.0.0.1:60050 - "GET /treni/5 HTTP/1.1" 200 OK
INFO: 127.0.0.1:60050 - "GET /treni/99 HTTP/1.1" 404 Not FoundLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Nessun controllo sul 404 | Il corpo del 404 è {"detail": "Treno non trovato"}: KeyError: 'codice' | test_un_treno_tolto_da_none |
client.get("/treni/{treno_id}"), senza la f | Le graffe restano lì, lettera per lettera: nel terminale del server arriva GET /treni/%7Btreno_id%7D (le graffe, codificate). InfoMenta non riesce a farne un int e risponde 422. Il corpo non ha codice: KeyError: 'codice' | test_il_codice_di_un_treno, test_un_treno_tolto_da_none |
client.get("/treni", params={"treno_id": treno_id}) | L'id nella query, invece che nel percorso. GET /treni ignora il parametro che non conosce e risponde con tutti i treni, in una lista: TypeError: list indices must be integers or slices, not str | test_il_codice_di_un_treno, test_un_treno_tolto_da_none |
La terza è la confusione più comune tra percorso e query: «quale cosa» va nel percorso (/treni/5), «quali cose, filtrate come» va nella query (/treni?tipo=tram).
3 · Aperte, chiuse o tutte
In italiano.
- Preparo un dizionario di parametri, vuoto.
- Se c'è un filtro (cioè
apertanon èNone), lo aggiungo. - Chiedo le stazioni con quei parametri: con il dizionario vuoto, nessuna query.
- Dal JSON tengo solo i nomi.
def nomi_stazioni(client: httpx.Client, aperta: bool | None = None) -> list[str]:
parametri = {}
if aperta is not None:
parametri["aperta"] = aperta
risposta = client.get("/stazioni", params=parametri)
nomi = []
for stazione in risposta.json():
nomi.append(stazione["nome"])
return nomiIl disegno.
Passo per passo. Le tre chiamate, e la richiesta che arriva al server:
| La chiamata | parametri | Nel terminale del server | Cosa torna |
|---|---|---|---|
nomi_stazioni(client, True) | {"aperta": True} | GET /stazioni?aperta=true | le cinque aperte |
nomi_stazioni(client, False) | {"aperta": False} | GET /stazioni?aperta=false | ["Vecchia Fiera"] |
nomi_stazioni(client) | {} | GET /stazioni | tutte e sei |
httpx scrive True come true, minuscolo, come lo vuole il JSON. E se il parametro lo mandi lo stesso, con None?
risposta = client.get("/stazioni", params={"aperta": None})
print(risposta.status_code)
print(risposta.json())422
{'detail': [{'type': 'bool_parsing', 'loc': ['query', 'aperta'], 'msg': 'Input should be a valid boolean, unable to interpret input', 'input': ''}]}Nel terminale del server, la richiesta è GET /stazioni?aperta=: il parametro c'è, ma vuoto, e un testo vuoto non è né true né false.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
params={"aperta": aperta}, sempre | Con None parte ?aperta= vuoto: 422. Il corpo è un dizionario con detail, il for gira sulle sue chiavi (la stringa "detail"), e stazione["nome"] dà TypeError: string indices must be integers, not 'str' | test_tutte_le_stazioni |
if aperta: al posto di if aperta is not None: | False per l'if è falso come None: con aperta=False il filtro non parte, e arrivano tutte e sei | test_le_stazioni_chiuse |
La seconda è la trappola del capitolo Le condizioni: if valore: non chiede «c'è?», chiede «è vero?». Per sapere se un filtro c'è, si chiede is not None.
4 · L'altoparlante
In italiano.
- Mando l'annuncio con una POST, il testo nel corpo JSON.
- Se il codice non è 201, l'annuncio non è stato creato:
None. - Altrimenti leggo il JSON e restituisco l'id scelto da InfoMenta.
def nuovo_annuncio(client: httpx.Client, testo: str) -> int | None:
risposta = client.post("/annunci", json={"testo": testo})
if risposta.status_code != 201:
return None
annuncio = risposta.json()
return annuncio["id"]Il disegno.
!= 201 copre in una riga sola tutti i «no»: il 422 del testo vuoto, il 429 dell'altoparlante stanco, e qualsiasi altro codice arrivi un domani.
python3 palestra/annuncio.py1Lancialo quattro volte di fila, entro un minuto: la quarta stampa None. È il 429.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
data={"testo": testo} al posto di json= | È il -d senza Content-Type dell'esempio B: il corpo parte come modulo, InfoMenta risponde 422, e la funzione dà sempre None | test_il_primo_annuncio_ha_l_id_1, test_due_annunci_due_id, test_un_annuncio_vuoto_da_none, test_il_quarto_annuncio_in_un_minuto_da_none |
if risposta.status_code != 200: | Una POST che crea risponde 201, non 200: per la funzione ogni annuncio è andato male | tutti e quattro |
| Nessun controllo sul codice | Con il testo vuoto (422) e con il quarto annuncio (429) il corpo ha solo detail: KeyError: 'id' | test_un_annuncio_vuoto_da_none, test_il_quarto_annuncio_in_un_minuto_da_none |
if risposta.status_code == 422: | Il testo vuoto è a posto, ma il 429 no: KeyError: 'id' | test_il_quarto_annuncio_in_un_minuto_da_none |
L'ultima insegna una cosa: elencare i codici sbagliati non finisce mai. Meglio dire qual è quello giusto (!= 201) e trattare tutto il resto come un no.
5 · Il vecchio indirizzo
In italiano.
- Chiedo il percorso, dicendo al client di non seguire i rimandi.
- Se il codice non è 301, non c'è nessun rimando:
None. - Altrimenti restituisco l'header
locationdella risposta.
def dove_porta(client: httpx.Client, percorso: str) -> str | None:
risposta = client.get(percorso, follow_redirects=False)
if risposta.status_code != 301:
return None
return risposta.headers["location"]python3 palestra/vecchio_indirizzo.py/partenze?stazione_id=1Con un httpx.Client anche senza follow_redirects=False funzionerebbe: httpx i rimandi non li segue, se non glielo dici. Ma il TestClient sì (l'esempio E). Scriverlo rende la funzione giusta con tutti e due i client.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
client.get(percorso), senza follow_redirects=False | Il TestClient segue il rimando da solo e arriva a /partenze: il codice è 200, e la funzione dà None | test_il_vecchio_indirizzo_degli_orari, test_il_rimando_tiene_la_query |
| Nessun controllo sul 301 | /partenze risponde 200 e non ha l'header location: KeyError: 'location' | test_un_indirizzo_che_non_rimanda |
La prima è subdola: dal vivo, lanciando il file, sembra funzionare. Sono i test a scoprirla.
6 · Il registro del deposito
In italiano.
- Chiedo il registro, con il badge nell'header
Authorization, dopo la parolaBearere uno spazio. - Se il codice è 401: «Chi sei?».
- Se è 403: «So chi sei, ma non puoi».
- Altrimenti è il 200: dal JSON prendo l'ultimo evento e compongo la frase.
def leggi_registro(client: httpx.Client, badge: str) -> str:
risposta = client.get("/deposito/registro", headers={"Authorization": f"Bearer {badge}"})
if risposta.status_code == 401:
return "Chi sei?"
if risposta.status_code == 403:
return "So chi sei, ma non puoi"
eventi = risposta.json()
ultimo = eventi[-1]
return f"Ultimo evento: {ultimo['ora']} {ultimo['treno']} {ultimo['evento']}"Il disegno.
Passo per passo, le tre chiamate dell'esempio:
| Il badge | L'header che parte | Il codice | Il ramo | La frase |
|---|---|---|---|---|
"B-12" | Authorization: Bearer B-12 | 200 | nessun if: si arriva in fondo | Ultimo evento: 04:55 M12 uscita |
"B-07" | Authorization: Bearer B-07 | 403 | il secondo if | So chi sei, ma non puoi |
"B-99" | Authorization: Bearer B-99 | 401 | il primo if | Chi sei? |
python3 palestra/registro.pyUltimo evento: 04:55 M12 uscita
So chi sei, ma non puoi
Chi sei?E nel terminale del server, le stesse tre richieste con i loro codici:
INFO: 127.0.0.1:60060 - "GET /deposito/registro HTTP/1.1" 200 OK
INFO: 127.0.0.1:60060 - "GET /deposito/registro HTTP/1.1" 403 Forbidden
INFO: 127.0.0.1:60060 - "GET /deposito/registro HTTP/1.1" 401 UnauthorizedIl badge non compare nel terminale del server: uvicorn scrive il percorso e la query, ma non gli header. È uno dei motivi per cui i dati riservati viaggiano negli header e non nella query.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
headers={"Authorization": badge}, senza Bearer | InfoMenta vuole Bearer B-12, non B-12: per lei il badge manca, e risponde sempre 401 | test_il_capo_deposito_legge_l_ultimo_evento, test_un_badge_vero_ma_senza_permesso |
f"Bearer{badge}", senza lo spazio | Parte BearerB-12: lo stesso 401 di prima | test_il_capo_deposito_legge_l_ultimo_evento, test_un_badge_vero_ma_senza_permesso |
eventi[0] | Il primo evento della lista, non l'ultimo: Ultimo evento: 22:10 M14 rientro | test_il_capo_deposito_legge_l_ultimo_evento |
Un if per il 200 e un else con "Chi sei?" | Il 403 finisce nell'else: Marta Villa, che InfoMenta conosce benissimo, si sente chiedere chi è | test_un_badge_vero_ma_senza_permesso |
Il test del badge sconosciuto resta verde con tutte e quattro: per questo i test sono tre, uno per codice. Cosa vogliono dire davvero 401 e 403, e come si fa un login vero, lo vedi in Chi sei, cosa puoi fare.
Tutti verdi? Lancia pytest da solo, senza nome di file: deve dire 18 passed. Poi passa al capitolo dopo, Il primo server: dall'altra parte del filo.