Vai al contenuto
code-to-code

Apro l'indice…

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

Login e sicurezza3. Depends, da zerop. 73

Depends, da zero, la palestra

Otto esercizi da scaricare, con i test

  • 120–150 minuti di lavoro

Otto esercizi, dal ★ al ★★★, sullo stesso argomento: Depends. Ogni esercizio è un'API piccola di un posto diverso della Linea Menta (un tabellone, un taxi, le biciclette, la piscina…), e ognuno ti chiede di scrivere qualcosa: un controllo da spostare in una funzione, un controllore intero, una dipendenza con i parametri della query. Quasi niente è già pronto.

Gli esercizi da scaricare

Una cartella con i file da completare e i test già pronti. Come si usa: la guida in cinque passi.

login-depends.zip19 KB

Prima di iniziare

Scompatta lo zip e segui il README.md che c'è dentro: venv, pip install, code .. Qui non serve nessun .env: le chiavi dei test sono finte e scritte nei file, solo per esercitarsi.

Ogni esercizio, sempre gli stessi quattro passi:

  1. Apri il file in palestra/. In alto: la storia, cosa fai, come provi.
  2. Al posto della riga raise HTTPException(status_code=501, …) (o dove dice «DA FARE») scrivi il codice. In commento, sopra, trovi cosa deve rispondere la rotta in ogni caso.
  3. pytest palestra/test_<nome>.py -v, oppure la provetta di VS Code.
  4. Rosso? Leggi l'ultima riga del messaggio: dice cosa fare. Bloccato da 15 minuti? Apri il primo aiutino, non la soluzione.

7 allenatori, poi il capopalestra

I test di una sfida sono verdi? Tocca il suo pallino: è battuta.

  1. 1Il tabellonetogliere il controllo copiato da tre rotte★allenatore
  2. 2Il taxiil parametro vale il return★allenatore
  3. 3Le bicicletteil controllore, con più chiavi★★allenatore
  4. 4Gli oggetti smarrititrovare i tre errori★★allenatore
  5. 5L'archivio a pagineuna dipendenza con i parametri della query★★allenatore
  6. 6La piscinauna dipendenza dentro l'altra★★allenatore
  7. 7Il registrodependencies=[…] su una rotta e su un router★★allenatore
  8. 8L'orologiouna dipendenza che prepara, e il test che la sostituisce★★★capopalestra

La medaglia · Depends, da zero

0 su 8: si accende quando le hai battute tutte.


1 · Il tabellone ★

palestra/tabellone.py

Il tabellone di Porta Codice legge ogni minuto tre elenchi dall'API: i ritardi, i binari, gli avvisi. Le tre rotte ci sono, ma rispondono a chiunque. Devono rispondere solo a chi manda la chiave giusta, nell'header X-API-Key. Scrivi il controllo una volta, in controlla_chiave, e mettilo nelle tre rotte con una riga ciascuna.

GET /ritardi   senza header                →  401  "Manca la chiave"
GET /binari    con una chiave sbagliata    →  401  "Chiave sbagliata"
GET /avvisi    con la chiave giusta        →  200  e l'elenco

Come provi: pytest palestra/test_tabellone.py -v

Aiutino 1
Il controllo è quello del capitolo 2: due if e un return. Sta in una funzione che non ha @app, e il suo parametro è chiave: str | None = Header(default=None, alias="X-API-Key"). Nel commento sopra c'è scritto tutto.
Aiutino 2
Alle tre rotte non cambia il corpo, solo la riga del def: dentro le parentesi aggiungi un parametro che chiama il controllore. La forma è nel commento: nome, tipo, = Depends(…).
Aiutino 3
Depends(controlla_chiave), senza parentesi dopo controlla_chiave. Se una rotta risponde 200 anche senza chiave, guarda se ti sei dimenticato di una delle tre.

2 · Il taxi ★

palestra/taxi.py

Un'azienda di taxi ha un'app che ogni notte chiede alla Linea Menta quali uscite delle stazioni sono aperte. Il controllore delle chiavi c'è già: riconosce due aziende, Taxi Navigli e Taxi Brera, e restituisce il nome di quella che ha bussato. La rotta no: scrivi GET /uscite, che usa il controllore con Depends e nella risposta scrive il nome dell'azienda.

GET /uscite   con la chiave di Taxi Navigli   →  200  {"azienda": "Taxi Navigli", "uscite": […]}
GET /uscite   con la chiave di Taxi Brera     →  200  {"azienda": "Taxi Brera", "uscite": […]}
GET /uscite   senza chiave, o sbagliata       →  401, lo manda il controllore

Come provi: pytest palestra/test_taxi.py -v

Aiutino 1
Il 401 non lo scrivi tu: lo manda controlla_chiave, che c'è già. A te serve solo chiamarlo, con un parametro nel def.
Aiutino 2
Il parametro è azienda: str = Depends(controlla_chiave). Dentro la rotta, azienda vale quello che il controllore ha restituito: non devi cercarlo da nessuna parte.
Aiutino 3
La risposta è un dizionario con due chiavi: "azienda" (il parametro) e "uscite" (la lista USCITE, già nel file). Non scrivere il nome dell'azienda a mano: cambia a seconda della chiave.

3 · Le biciclette ★★

palestra/biciclette.py

Ponte Ciclo, il sistema delle biciclette in prestito, apre le sue rotte a due programmi: l'app Pedala e il totem di Porta Codice. Ognuno ha la sua chiave, nel dizionario CHIAVI. Scrivi controlla_chiave: legge X-API-Key, cerca la chiave nel dizionario e restituisce il nome del programma. Le due rotte (/biciclette e /stalli) sono già fatte, e scrivono nella risposta chi ha bussato. Se un programma perde la sua chiave, la si toglie dal dizionario: quella non entra più, le altre sì.

nessun header X-API-Key        →  401  "Manca la chiave"
chiave che non è in CHIAVI     →  401  "Chiave sbagliata"
chiave giusta                  →  il nome del programma, per la rotta

Come provi: pytest palestra/test_biciclette.py -v

Aiutino 1
Tre casi, nell'ordine: l'header non c'è (None), la chiave non è nel dizionario, tutto bene. I primi due sono un raise HTTPException(status_code=401, …), il terzo un return.
Aiutino 2
Per cercare una chiave che potrebbe non esserci, con le quadre il programma si ferma con un KeyError (un 500). Quale lettura dà None e basta? Lo hai visto nei dizionari.
Aiutino 3
Il valore nel dizionario è il nome del programma: CHIAVI.get(chiave). Se è None, la chiave è sbagliata; altrimenti, è quello da restituire.

4 · Gli oggetti smarriti ★★

palestra/smarriti.py

L'ufficio oggetti smarriti ha un'app, Cercaperso, che legge tre elenchi: gli oggetti in deposito, le denunce, i ritrovati. Qualcuno ha scritto tutto, ma nel file ci sono tre errori, uno per ogni guaio che si fa con Depends. Non devi scrivere funzioni nuove: devi leggere gli errori e trovare le righe.

le tre rotte, con la chiave giusta       →  200, e nella risposta "programma": "Cercaperso"
senza chiave                             →  401  "Manca la chiave"
con una chiave sbagliata                 →  401  "Chiave sbagliata"

Come provi: pytest palestra/test_smarriti.py -v. Per ora il test non parte nemmeno: leggi l'errore.

Aiutino 1
Il primo errore è quello che ferma il file prima dei test, mentre Python lo legge. Leggi la riga dopo in <module>: dice dove. Ripassa la regola 2 della teoria.
Aiutino 2
Il secondo lo vedi come un 422: una rotta non chiama il controllore, e il suo parametro è diventato uno della query. Guarda i tre def uno sotto l'altro: quale ha qualcosa di diverso?
Aiutino 3
Il terzo non dà nessun errore: dice "programma": null. Guarda l'ultima riga di controlla_chiave: il parametro della rotta vale quello che il controllore restituisce.

5 · L'archivio a pagine ★★

palestra/archivio.py

L'archivio della Linea Menta ha tre elenchi lunghi: i treni (25), le stazioni (12), i guasti (30). Chi li chiede non li vuole tutti insieme, ma a pagine: GET /treni?limite=5&salta=10 vuol dire «cinque treni, saltando i primi dieci». Senza parametri, i primi dieci. Scrivi la dipendenza paginazione (con limite e salta) e usala nelle tre rotte, al posto delle tre copie.

GET /treni                       →  i primi 10 treni
GET /treni?limite=3              →  i primi 3
GET /stazioni?limite=4&salta=5   →  4 stazioni, dalla sesta
GET /treni?salta=20              →  gli ultimi 5 (ne restano 5, non 10)
GET /guasti?salta=100            →  []

Come provi: pytest palestra/test_archivio.py -v

Aiutino 1
paginazione è una funzione normale con due parametri interi, con un valore predefinito ciascuno (10 e 0). I parametri della dipendenza arrivano dalla query, come in una rotta.
Aiutino 2
Restituisce un piccolo dizionario: {"limite": limite, "salta": salta}. Nelle rotte, pagina: dict[str, int] = Depends(paginazione).
Aiutino 3
La fetta di un elenco è ELENCO[da:a]. Qui da è salta, e a è salta + limite: non limite da solo.

6 · La piscina ★★

palestra/piscina.py

La piscina comunale ha due programmi: l'app degli iscritti e il tornello d'ingresso. Il lavoro è diviso in due funzioni: leggi_chiave legge l'header (c'è già), programma_corrente decide chi è. Questa la scrivi tu. Non legge l'header lei: il suo parametro chiave le arriva dall'altra dipendenza. Le due rotte (/corsie e /prenotazioni) usano già programma_corrente.

leggi_chiave dà None            →  401  "Manca la chiave"
chiave che non è in CHIAVI      →  401  "Chiave sbagliata"
chiave giusta                   →  il nome del programma

Come provi: pytest palestra/test_piscina.py -v

Aiutino 1
Il parametro chiave di programma_corrente è l'unico pezzo che cambia rispetto all'esercizio 3: non più = Header(…), ma = Depends(leggi_chiave).
Aiutino 2
Per il resto, il corpo è lo stesso: None → 401 «Manca la chiave»; cerca nel dizionario; non c'è → 401 «Chiave sbagliata»; c'è → il nome.
Aiutino 3
Se leggi_chiave dà None, CHIAVI.get(None) darebbe None senza errori, ma con il messaggio sbagliato: il primo if deve venire prima.

7 · Il registro ★★

palestra/registro.py

Il registro del deposito ha rotte aperte e rotte chiuse. Il controllore c'è già, ma nelle rotte chiuse il nome di chi bussa non serve a nessuno: basta fermare chi non ha la chiave. Quindi niente parametro nel def: dependencies=[…]. POST /allarme lo metti nel decoratore. Le tre rotte di /interventi lo mettono tutte insieme, nell'APIRouter. GET /stato resta aperta a tutti.

GET /stato                         →  200, senza chiave
POST /allarme    senza chiave      →  401  "Manca la chiave"
GET /interventi/99   senza chiave  →  401  (non 404: il controllore parte per primo)
GET /interventi/99   con la chiave →  404

Come provi: pytest palestra/test_registro.py -v

Aiutino 1
La forma è dependencies=[Depends(controlla_chiave)]: una lista, con Depends dentro, senza parentesi dopo controlla_chiave. Si scrive dopo il percorso, tra le parentesi del decoratore.
Aiutino 2
Per il router, la riga è nella creazione: APIRouter(prefix="/interventi", dependencies=[…]). Le tre rotte del router non cambiano.
Aiutino 3
GET /stato non si tocca. Se il test dice che è diventata chiusa, hai messo la dipendenza dove vale per tutta l'app, o su quella rotta.

8 · L'orologio ★★★

palestra/orologio.py

La metropolitana chiude dalle 00:30 (compresa) alle 05:30 (esclusa). GET /aperto dice se la linea è aperta adesso, e a che ora l'ha deciso. Per provarla senza aspettare le tre di notte, l'ora non si legge dentro la rotta: la porta una dipendenza, adesso, che non controlla niente e non ferma niente, prepara. Il test se ne inventa una finta: app.dependency_overrides dice a FastAPI «al posto di adesso, usa questa».

alle 03:00   GET /aperto  →  {"ora": "03:00", "aperta": false}
alle 12:00   GET /aperto  →  {"ora": "12:00", "aperta": true}
alle 00:30   GET /aperto  →  {"ora": "00:30", "aperta": false}
alle 05:30   GET /aperto  →  {"ora": "05:30", "aperta": true}

Come provi: pytest palestra/test_orologio.py -v

Aiutino 1
adesso è una funzione di una riga: restituisce datetime.now(). Senza @app, senza parametri, senza raise.
Aiutino 2
La rotta riceve l'ora così: ora: datetime = Depends(adesso). Non chiamare datetime.now() dentro la rotta: il test non potrebbe sostituire l'orologio, e la rotta direbbe sempre l'ora vera.
Aiutino 3
Per decidere, i minuti dalla mezzanotte: ora.hour * 60 + ora.minute. La linea è chiusa se sono CHIUSURA <= minuti < APERTURA. Per la risposta, f"{ora:%H:%M}" scrive l'ora come 03:00.