Login e rotte protette, se qualcosa va storto
Gli errori del login e del controllore, e quelli che non fanno rumore
Gli errori che vedrai di più in questo capitolo. Per ognuno: cosa leggi, cosa vuol dire, cosa fai.
Ricorda come si legge un traceback: dal basso. L'ultima riga dice cosa, la riga con i ^^^ dice quale pezzo, la riga File … line … dice dove. Tutto il resto è nel capitolo Leggere un traceback. Con un server acceso, il traceback è nel terminale del server, non in quello di curl: al client arriva solo Internal Server Error.
Il codice
| Leggi | Vuol dire | Cosa fai |
|---|---|---|
AttributeError: 'NoneType' object has no attribute 'credentials' (nel terminale del server, e 500 Internal Server Error per il client) | Nel controllore usi header.credentials, ma header è None: la richiesta non aveva il biglietto | Prima di leggerlo: if header is None: e 401 «Manca il biglietto» |
KeyError: None (o KeyError: 'fantasma') | Nel controllore cerchi l'utente con le quadre: utenti[username]. Con un biglietto che non vale username è None, e None non è una chiave | utenti.get(username), e poi if utente is None: con il 401 |
{"detail":"Not authenticated"}, con un header www-authenticate: Bearer | Il controllore è un HTTPBearer() senza auto_error=False: risponde lui, con il suo messaggio | Usa il controllore di sicurezza.py: HTTPBearer(auto_error=False). Il 401 con il tuo messaggio lo scrive utente_corrente |
{"detail":[{"type":"missing","loc":["body"],"msg":"Field required","input":null}]} su una rotta che è un GET | Il parametro utente: UtenteSalvato non ha = Depends(utente_corrente): per FastAPI è un corpo da leggere dalla richiesta | utente: UtenteSalvato = Depends(utente_corrente) |
{"detail":[{"type":"missing","loc":["body","password"],"msg":"Field required",…}]} al login | Nel corpo del login manca un campo (qui password) | loc dice dove, msg dice cosa. Il corpo vuole tutti e due: username e password |
{"detail":[{"type":"model_attributes_type","loc":["body"],"msg":"Input should be a valid dictionary or object to extract fields from",…}]} al login | Il corpo non è JSON: è arrivato come testo semplice, per esempio username=lucia&password=… | In Postman: Body → raw → JSON. In curl: -H "Content-Type: application/json" e il corpo con le virgolette doppie |
/login risponde 401 con la password giusta | Quasi sempre: uno spazio o una maiuscola in più nello username, o la password di un altro utente. Il messaggio è uguale per tutti i guai, apposta | Controlla username e password, lettera per lettera, con la tabella degli utenti del README |
assert 501 == 200 (o 201, o 401) | C'è ancora la riga «da fare»: raise HTTPException(status_code=501, …) | Al posto di quella riga, il tuo codice |
RuntimeError: Manca SECRET_KEY: crea il file .env (README, «Una volta sola») accendendo il server | Manca il file .env nella cartella principale: senza chiave non si firma nessun biglietto | Il comando della chiave, nel README: python3 -c "import secrets; print('SECRET_KEY=' + secrets.token_hex(32))" > .env. I test no: usano una chiave loro |
Address already in use | C'è già un server acceso, in un altro terminale | Ctrl+C di là, oppure fastapi dev … --port 8001 |
La richiesta
| Leggi | Vuol dire | Cosa fai |
|---|---|---|
{"detail":"Manca il biglietto"}, ma il biglietto lo stai mandando | Non è arrivato un header Authorization: Bearer … fatto bene: manca la parola Bearer, o lo spazio, o l'header ha un altro nome | curl: -H "Authorization: Bearer $BIGLIETTO". Postman: Authorization → Bearer Token, non una riga a mano |
{"detail":"Biglietto non valido"} appena fatto il login | Il biglietto è stato letto, ma non vale. Quasi sempre: sono passati 30 minuti; oppure in /docs hai incollato Bearer eyJ… nel lucchetto (la parola la aggiunge da sola); oppure hai incollato le virgolette | Rifai il login e incolla solo il valore di access_token, senza virgolette e senza Bearer |
{"detail":"Biglietto non valido"} con un biglietto fresco, dopo aver salvato un file | fastapi dev ricarica il programma a ogni salvataggio, e il dizionario utenti torna com'era: la persona registrata a mano non c'è più. Il biglietto vale, ma l'utente no | Registrala di nuovo e rifai il login. Vedi sotto: «Il server riparte, il dizionario torna» |
{"detail":"Biglietto non valido"} dopo aver cambiato il .env | La chiave è nuova: i biglietti fatti con la vecchia hanno una firma che non torna più | Rifai il login con il server riavviato |
{{biglietto}} resta rosso in Postman | La variabile non c'è: lo script del login non è partito, o non ha salvato niente | Scripts → Post-response: pm.collectionVariables.set("biglietto", pm.response.json().access_token);. Poi rifai il login, e controlla di averla scritta nella collezione |
Could not send request o ECONNREFUSED in Postman | Postman non raggiunge il server: spento, oppure l'indirizzo è sbagliato. O stai usando Postman nel browser, che non vede il tuo computer | Controlla che fastapi dev sia acceso, e che baseUrl sia http://127.0.0.1:8000. Usa l'app desktop |
/me risponde 401 in Postman, ma il login ha funzionato | La richiesta di /me non manda il biglietto: l'Auth Type della richiesta non è Bearer Token, oppure il biglietto è scaduto | Imposta Bearer Token con {{biglietto}}. Scaduto: rifai il login |
| 403 al posto di 401 (o 404 al posto di 401) | Hai confuso le domande. 401: non so chi sei. 403: so chi sei, ma qui non entri. 404: quello che chiedi non c'è | Un biglietto che manca o non vale è sempre 401. Il 403 comincia nel capitolo sui permessiin arrivo |
Il server riparte, il dizionario torna
Il caso più strano di questo capitolo, e vero: tutto funziona, poi salvi un file e la tua persona sparisce. Con la storia accesa (fastapi dev storia/main.py), questo è quello che succede:
curl -s -X POST http://127.0.0.1:8000/personale -H "Content-Type: application/json" -d '{"username": "bruno", "nome": "Bruno Gatti", "password": "linea-verde-33"}'
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer $BIGLIETTO"
touch storia/main.py # come salvare il file
curl -s http://127.0.0.1:8000/me -H "Authorization: Bearer $BIGLIETTO"
curl -s -X POST http://127.0.0.1:8000/login -H "Content-Type: application/json" -d '{"username": "bruno", "password": "linea-verde-33"}'{"username":"bruno","nome":"Bruno Gatti"}
{"username":"bruno","nome":"Bruno Gatti"}
{"detail":"Biglietto non valido"}
{"detail":"Username o password sbagliati"}La prima risposta è la registrazione, la seconda è /me con il biglietto di Bruno ($BIGLIETTO, preso con un login subito dopo la registrazione). Nel terminale del server compare WatchFiles detected changes … Reloading: il programma è ripartito, e utenti è tornato com'era scritto nel codice, cioè vuoto. Il biglietto di Bruno vale ancora (la chiave è sempre la stessa), ma Bruno non c'è più: è proprio il quinto 401 della teoria. Con un database i dati resterebbero; con un dizionario, no: si registra di nuovo.
Gli errori che non danno errori
I più difficili sono quelli senza traceback: il programma gira, le richieste vanno, il test (se c'è) resta verde. Qui sono tutti buchi di sicurezza, e si vedono solo con un test che li cerca.
Il nome al posto dello username. crea_biglietto(utente.nome): il login risponde 200, ma nel biglietto c'è «Lucia Ferri», e il controllore non la trova. Ogni richiesta dopo è un 401.
Chi sei, preso dal posto sbagliato. Uno username letto dal corpo, dall'indirizzo o da un parametro (?username=lucia): sembra comodo, e permette a chiunque di essere chiunque. L'utente è sempre quello del biglietto.
Due messaggi per due guai al login. «Username non trovato» e «Password sbagliata»: funziona, ma dice a un estraneo chi lavora alla Linea Menta.
Il biglietto letto, non controllato. jwt.decode(…, options={"verify_signature": False}): si legge lo username e tutto funziona. Ma un biglietto cambiato a mano passa, uno scaduto passa, uno firmato con un'altra chiave passa. Per leggere il biglietto si usa leggi_biglietto.
L'impronta nella risposta. -> UtenteSalvato dove serve -> Utente: lo stampo della risposta è il solo filtro. Nessun errore: lo vedi solo leggendo la risposta.
Il 404 dove serve il 401. Se una rotta cerca la cosa (/porte/binario-9/apri) prima di chiedersi chi sei, a chi non ha un biglietto dice «Porta non trovata»: gli racconta cosa esiste. Prima il 401, poi il 404.
Per trovarli, nell'ordine: un test che prova la rotta con un biglietto di un'altra persona, con un biglietto cambiato, con nessun biglietto. E il debugger, se la risposta è strana: un breakpoint dentro utente_corrente, e in WATCH header, username, utente. Come si fa: Il debugger con FastAPI e i test.
Se il problema non è il codice
pytest: command not found, No module named 'pwdlib' (o 'jwt', 'dotenv'), il pannello Testing vuoto, No module named 'login': non è il tuo codice, è l'ambiente. Ha una pagina sua nel Pronto soccorso: pytest non parte, o non trova niente. Le cure brevi per Postman e il login (Could not send request, {{biglietto}}, il 422 del corpo) sono nel Pronto soccorso.