Depends, da zero, 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 sono errori che non fanno nessun rumore.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · Il tabellone
In italiano. Una funzione controlla_chiave con i due if e il return, scritta una volta. Poi, in ognuna delle tre rotte, un parametro che la chiama con Depends. Il corpo delle rotte non cambia.
def controlla_chiave(chiave: str | None = Header(default=None, alias="X-API-Key")) -> str:
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
if chiave != CHIAVE_TABELLONE:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return "tabellone"
@app.get("/ritardi")
def leggi_ritardi(programma: str = Depends(controlla_chiave)) -> dict:
return {"ritardi": RITARDI}(/binari e /avvisi hanno la stessa riga.) Il parametro programma qui non lo usa nessuno: è il prezzo di Depends nel def. Nell'esercizio 7 vedi come evitarlo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il parametro Depends su due rotte e non sulla terza (/avvisi) | Nessun errore: la terza porta resta aperta a tutti, ed è il guaio del controllo copiato che torna dalla finestra | test_senza_chiave, test_chiave_sbagliata |
Manca il primo if (chiave is None) | Senza header, None != CHIAVE_TABELLONE è vero: la risposta è 401, ma con «Chiave sbagliata» al posto di «Manca la chiave» | test_senza_chiave |
Header(default=None), senza alias | FastAPI cerca un header che si chiama chiave, non X-API-Key: non lo trova mai, e anche chi manda la chiave giusta riceve 401 | test_chiave_sbagliata, test_chiave_giusta, test_i_ritardi_arrivano, test_i_binari_arrivano, test_gli_avvisi_arrivano |
Manca il return "tabellone" | Le rotte rispondono bene, perché non usano il valore. Il guaio c'è per chi lo userà: sarà None | test_il_controllore_e_una_funzione_sola |
2 · Il taxi
In italiano. Alla rotta aggiungo il parametro del controllore. Dentro, azienda è già il nome di chi ha bussato: lo metto nella risposta.
@app.get("/uscite")
def leggi_uscite(azienda: str = Depends(controlla_chiave)) -> dict:
return {"azienda": azienda, "uscite": USCITE}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
{"azienda": "Taxi Navigli", …} scritto a mano | Con la chiave di Navigli va tutto bene, e con quella di Brera la risposta dice Navigli: il controllore lavora, e la rotta non lo ascolta | test_taxi_brera |
def leggi_uscite(azienda: str) -> dict: (manca = Depends(controlla_chiave)) | Per FastAPI azienda è un parametro della query, richiesto: 422, e il controllore non parte mai. Con /uscite?azienda=io la rotta risponderebbe a chiunque | test_taxi_navigli, test_taxi_brera, test_senza_chiave, test_chiave_sbagliata |
La seconda fa rossi tutti e quattro i test: la protezione stava in quel = Depends(…).
3 · Le biciclette
In italiano.
- Se l'header non c'è: 401, «Manca la chiave».
- Cerco la chiave nel dizionario. Se non c'è: 401, «Chiave sbagliata».
- Altrimenti restituisco il nome del programma.
def controlla_chiave(chiave: str | None = Header(default=None, alias="X-API-Key")) -> str:
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
programma = CHIAVI.get(chiave) # None se la chiave non c'è (o è stata tolta)
if programma is None:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return programmaIl dizionario fa due lavori in uno: dice se la chiave esiste, e dice chi è. Togliere una riga dal dizionario revoca quel programma, senza toccare il codice.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Manca il primo if | Senza header, CHIAVI.get(None) dà None: la risposta è 401, ma «Chiave sbagliata» | test_senza_chiave |
return chiave al posto di return programma | La rotta risponde 200 e scrive "programma": "chiave-di-prova-pedala": la chiave stessa, nella risposta, al posto del nome | test_pedala_entra_e_si_presenta, test_il_totem_entra_e_si_presenta, test_togliere_una_chiave_non_disturba_le_altre |
programma = CHIAVI[chiave] | Con una chiave che non c'è, KeyError: un 500 al posto del 401 | test_chiave_sbagliata, test_una_chiave_tolta_non_entra_piu |
4 · Gli oggetti smarriti
In italiano. Tre errori, in tre posti:
Depends(controlla_chiave()): le parentesi. Python chiama il controllore mentre legge il file. Si toglie la coppia di parentesi.leggi_denunce(programma: str): senza= Depends(controlla_chiave),programmaè un parametro della query. Si aggiunge.controlla_chiavenon ha ilreturn: il parametro delle rotte valeNone. Si aggiungereturn "Cercaperso".
def controlla_chiave(chiave: str | None = Header(default=None, alias="X-API-Key")) -> str:
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
if chiave != CHIAVE_RITROVO:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return "Cercaperso"
@app.get("/oggetti")
def leggi_oggetti(programma: str = Depends(controlla_chiave)) -> dict:
return {"programma": programma, "oggetti": OGGETTI}
@app.get("/denunce")
def leggi_denunce(programma: str = Depends(controlla_chiave)) -> dict:
return {"programma": programma, "denunce": DENUNCE}Come si trovano. I tre errori si vedono in tre momenti diversi. Il primo ferma il file: il test non parte, e l'ultima riga è HTTPException: 401: Chiave sbagliata, con la riga in <module>. Il secondo si vede come 422, con "loc":["query","programma"]. Il terzo non si vede: lo trovi leggendo la risposta, "programma": null. Per questo il test controlla anche il nome.
Le trappole. Le due che si possono provare dopo aver risolto la prima (la prima ferma ogni test):
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Tolte le parentesi e aggiunto il return, ma leggi_denunce(programma: str) senza Depends | /denunce non chiama il controllore: 422 senza chiave, e con ?programma=io risponde a chiunque | test_senza_chiave, test_chiave_sbagliata, test_chiave_giusta, test_la_rotta_sa_chi_ha_bussato |
Tolte le parentesi e aggiunto il Depends, ma manca return "Cercaperso" | Le risposte sono 200 e hanno tutto tranne il nome: "programma": null | test_la_rotta_sa_chi_ha_bussato |
5 · L'archivio a pagine
In italiano. Una funzione con due parametri interi e i loro valori predefiniti, che restituisce un dizionario. Nelle tre rotte, un parametro Depends(paginazione) e la fetta: da salta a salta + limite.
def paginazione(limite: int = 10, salta: int = 0) -> dict[str, int]:
return {"limite": limite, "salta": salta}
@app.get("/treni")
def leggi_treni(pagina: dict[str, int] = Depends(paginazione)) -> list[str]:
return TRENI[pagina["salta"] : pagina["salta"] + pagina["limite"]]I parametri di paginazione vengono dalla query, perché sono tipi semplici con un valore predefinito: FastAPI li riconosce come per una rotta.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
TRENI[pagina["salta"] : pagina["limite"]] | Con salta=0 funziona (la fetta è [0:limite]). Con salta=5 e limite=4 la fetta è [5:4]: vuota | test_limite_e_salta_insieme, test_salta_da_solo |
Pagine solo su /treni, le altre due rotte restituiscono tutto | Nessun errore: due elenchi su tre sono ancora lunghi | test_senza_niente_i_primi_dieci, test_il_limite, test_limite_e_salta_insieme, test_oltre_la_fine_un_elenco_vuoto |
def paginazione(limite: int, salta: int) (senza valori predefiniti) | Senza limite e salta nella query, FastAPI risponde da solo 422: i parametri sono obbligatori | test_senza_niente_i_primi_dieci, test_il_limite, test_salta_da_solo, test_oltre_la_fine_un_elenco_vuoto, test_la_paginazione_e_una_dipendenza_sola |
6 · La piscina
In italiano. Come l'esercizio 3, ma la chiave non si legge dall'header: arriva dall'altra dipendenza. Il parametro cambia da = Header(…) a = Depends(leggi_chiave). Il resto è uguale.
def programma_corrente(chiave: str | None = Depends(leggi_chiave)) -> str:
if chiave is None:
raise HTTPException(status_code=401, detail="Manca la chiave")
programma = CHIAVI.get(chiave)
if programma is None:
raise HTTPException(status_code=401, detail="Chiave sbagliata")
return programmaPasso per passo, con la chiave del tornello:
| Anello | Cosa riceve | Cosa restituisce |
|---|---|---|
leggi_chiave | l'header X-API-Key: chiave-di-prova-ingresso | "chiave-di-prova-ingresso" |
programma_corrente | quella stringa, nel parametro chiave | "tornello d'ingresso" |
leggi_prenotazioni | quel nome, nel parametro programma | la risposta |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Manca il primo if | CHIAVI.get(None) dà None: 401, ma con «Chiave sbagliata» anche quando la chiave manca | test_senza_chiave |
return chiave | Il programma si presenta con la sua chiave, non con il suo nome | test_l_app_degli_iscritti, test_il_tornello |
7 · Il registro
In italiano. Due righe, due posti. Nel decoratore di POST /allarme: dependencies=[Depends(controlla_chiave)]. Nella riga che crea il router: lo stesso. GET /stato non si tocca.
@app.post("/allarme", status_code=201, dependencies=[Depends(controlla_chiave)])
def accendi_allarme() -> dict:
return {"allarme": "acceso"}
router = APIRouter(prefix="/interventi", dependencies=[Depends(controlla_chiave)])Le tre rotte del router non cambiano: ereditano il controllo. Ed è per questo che senza chiave anche /interventi/99 risponde 401: il controllore parte prima della rotta, quindi prima che qualcuno cerchi l'intervento 99.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
leggi_stato(programma: str = Depends(controlla_chiave)) | Hai chiuso anche la rotta che doveva restare aperta: il tabellone dello stato non riesce più a leggerla | test_lo_stato_resta_aperto |
APIRouter(prefix="/interventi"), senza dependencies | Le tre rotte del registro rispondono a tutti. Il test lo sa: senza chiave si aspetta 401 | test_il_router_e_chiuso, test_la_chiave_viene_prima_del_404 |
@app.post("/allarme", status_code=201), senza dependencies | Chiunque può accendere l'allarme | test_allarme_senza_chiave, test_allarme_con_chiave_sbagliata |
8 · L'orologio
In italiano.
adessorestituisce l'ora vera,datetime.now().- La rotta la riceve con
Depends(adesso): non la legge lei. - Calcolo i minuti dalla mezzanotte. Se sono tra
CHIUSURA(compresa) eAPERTURA(esclusa), la linea è chiusa. - Rispondo con l'ora scritta
HH:MMe il verdetto.
def adesso() -> datetime:
return datetime.now()
@app.get("/aperto")
def la_linea_e_aperta(ora: datetime = Depends(adesso)) -> dict:
minuti = ora.hour * 60 + ora.minute # minuti dalla mezzanotte
chiusa = CHIUSURA <= minuti < APERTURA
return {"ora": f"{ora:%H:%M}", "aperta": not chiusa}Perché si fa così. Il test mette in app.dependency_overrides[orologio.adesso] una funzione che restituisce l'ora che vuole. FastAPI, quando incontra Depends(adesso), usa quella al posto dell'originale. La rotta non lo sa e non deve saperlo. Se la rotta chiamasse datetime.now() da sola, il test non avrebbe nessun modo di cambiarle l'ora.
Passo per passo, alle 00:30 (minuti = 30):
| Pezzo | Valore |
|---|---|
ora | datetime(2026, 11, 20, 0, 30), quello del test |
minuti | 0 * 60 + 30 = 30 |
CHIUSURA <= minuti < APERTURA | 30 <= 30 < 330: vero |
| risposta | {"ora": "00:30", "aperta": false} |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
ora = datetime.now() dentro la rotta, senza Depends(adesso) | La rotta funziona, ma dice sempre l'ora vera: il test non può cambiarla | tutti quelli che scelgono un'ora: test_di_notte_e_chiusa, test_a_mezzogiorno_e_aperta, test_prima_della_chiusura, test_alla_chiusura, test_un_minuto_prima_dell_apertura, test_all_apertura |
CHIUSURA < minuti < APERTURA | Alle 00:30 la linea risulta ancora aperta: la chiusura non era compresa | test_alla_chiusura |
CHIUSURA <= minuti <= APERTURA | Alle 05:30 la linea risulta ancora chiusa: l'apertura era esclusa dalla chiusura | test_all_apertura |