Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza3. Depends, da zerop. 79

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.

login-depends-soluzioni.zip19 KB

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.

Python
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 sbagliatoCosa succedeIl 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 finestratest_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 aliasFastAPI cerca un header che si chiama chiave, non X-API-Key: non lo trova mai, e anche chi manda la chiave giusta riceve 401test_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à Nonetest_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.

Python
@app.get("/uscite")
def leggi_uscite(azienda: str = Depends(controlla_chiave)) -> dict:
    return {"azienda": azienda, "uscite": USCITE}

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
{"azienda": "Taxi Navigli", …} scritto a manoCon la chiave di Navigli va tutto bene, e con quella di Brera la risposta dice Navigli: il controllore lavora, e la rotta non lo ascoltatest_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 chiunquetest_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.

  1. Se l'header non c'è: 401, «Manca la chiave».
  2. Cerco la chiave nel dizionario. Se non c'è: 401, «Chiave sbagliata».
  3. Altrimenti restituisco il nome del programma.
Python
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 programma

Il 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 sbagliatoCosa succedeIl test rosso
Manca il primo ifSenza header, CHIAVI.get(None) dà None: la risposta è 401, ma «Chiave sbagliata»test_senza_chiave
return chiave al posto di return programmaLa rotta risponde 200 e scrive "programma": "chiave-di-prova-pedala": la chiave stessa, nella risposta, al posto del nometest_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 401test_chiave_sbagliata, test_una_chiave_tolta_non_entra_piu

4 · Gli oggetti smarriti

In italiano. Tre errori, in tre posti:

  1. Depends(controlla_chiave()): le parentesi. Python chiama il controllore mentre legge il file. Si toglie la coppia di parentesi.
  2. leggi_denunce(programma: str): senza = Depends(controlla_chiave), programma è un parametro della query. Si aggiunge.
  3. controlla_chiave non ha il return: il parametro delle rotte vale None. Si aggiunge return "Cercaperso".
Python
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 sbagliatoCosa succedeIl 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 chiunquetest_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": nulltest_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.

Python
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 sbagliatoCosa succedeIl 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]: vuotatest_limite_e_salta_insieme, test_salta_da_solo
Pagine solo su /treni, le altre due rotte restituiscono tuttoNessun errore: due elenchi su tre sono ancora lunghitest_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 obbligatoritest_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.

Python
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 programma

Passo per passo, con la chiave del tornello:

AnelloCosa riceveCosa restituisce
leggi_chiavel'header X-API-Key: chiave-di-prova-ingresso"chiave-di-prova-ingresso"
programma_correntequella stringa, nel parametro chiave"tornello d'ingresso"
leggi_prenotazioniquel nome, nel parametro programmala risposta

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Manca il primo ifCHIAVI.get(None) dà None: 401, ma con «Chiave sbagliata» anche quando la chiave mancatest_senza_chiave
return chiaveIl programma si presenta con la sua chiave, non con il suo nometest_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.

Python
@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 sbagliatoCosa succedeIl 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 leggerlatest_lo_stato_resta_aperto
APIRouter(prefix="/interventi"), senza dependenciesLe tre rotte del registro rispondono a tutti. Il test lo sa: senza chiave si aspetta 401test_il_router_e_chiuso, test_la_chiave_viene_prima_del_404
@app.post("/allarme", status_code=201), senza dependenciesChiunque può accendere l'allarmetest_allarme_senza_chiave, test_allarme_con_chiave_sbagliata

8 · L'orologio

In italiano.

  1. adesso restituisce l'ora vera, datetime.now().
  2. La rotta la riceve con Depends(adesso): non la legge lei.
  3. Calcolo i minuti dalla mezzanotte. Se sono tra CHIUSURA (compresa) e APERTURA (esclusa), la linea è chiusa.
  4. Rispondo con l'ora scritta HH:MM e il verdetto.
Python
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):

PezzoValore
oradatetime(2026, 11, 20, 0, 30), quello del test
minuti0 * 60 + 30 = 30
CHIUSURA <= minuti < APERTURA30 <= 30 < 330: vero
risposta{"ora": "00:30", "aperta": false}

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
ora = datetime.now() dentro la rotta, senza Depends(adesso)La rotta funziona, ma dice sempre l'ora vera: il test non può cambiarlatutti 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 < APERTURAAlle 00:30 la linea risulta ancora aperta: la chiusura non era compresatest_alla_chiusura
CHIUSURA <= minuti <= APERTURAAlle 05:30 la linea risulta ancora chiusa: l'apertura era esclusa dalla chiusuratest_all_apertura