La sessione, 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 la risposta e si rompono su un test che guarda nel database.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
Nei file dello zip le soluzioni hanno gli stampi e i commenti dello scheletro: qui sotto c'è solo il pezzo che hai scritto tu.
La palestra
1 · La stazione per numero
In italiano. Cerco la stazione dal suo id. Se non c'è (None), rispondo 404. Se c'è, la restituisco.
@app.get("/stazioni/{stazione_id}")
def leggi_stazione(stazione_id: int, db: Session = Depends(get_db)) -> Stazione:
stazione = db.get(StazioneDB, stazione_id)
if stazione is None:
raise HTTPException(status_code=404, detail="Stazione non trovata")
return stazionedb.get è fatta apposta per questo: cerca per chiave primaria, e dà l'oggetto oppure None. Lo stampo Stazione poi lo fa FastAPI: legge gli attributi dell'oggetto e ne fa il JSON.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
stazione = db.get(Stazione, stazione_id) | Hai passato lo stampo di Pydantic, non la classe-tabella: NoInspectionAvailable: No inspection system is available for object of type <class 'pydantic._internal._model_construction.ModelMetaclass'> | tutti e quattro |
niente if stazione is None | db.get dà None, la rotta lo restituisce, e FastAPI non riesce a farne una stazione: ResponseValidationError … Input should be a valid dictionary or object to extract fields from. Il client riceve un 500 invece del 404 | test_stazione_una_che_non_c_e_da_404 |
2 · Le stazioni aperte
In italiano. Scrivo la domanda in tre pezzi: da StazioneDB, solo dove aperta è vera, in ordine di nome. Poi la eseguo e restituisco la lista.
@app.get("/stazioni")
def stazioni_aperte(db: Session = Depends(get_db)) -> list[Stazione]:
domanda = select(StazioneDB).where(StazioneDB.aperta).order_by(StazioneDB.nome)
return db.scalars(domanda).all()La domanda sta in una variabile (domanda) per leggerla meglio: prima si scrive, poi si esegue. .scalars(…) tiene l'oggetto di ogni riga, .all() fa la lista.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
select(StazioneDB).order_by(StazioneDB.nome), senza where | Nessun errore: arrivano tutte e sei le stazioni, anche Vecchia Fiera, che è chiusa | test_stazioni_aperte_solo_quelle_aperte, test_stazioni_aperte_in_ordine_di_nome, test_stazioni_aperte_legge_il_database |
select(StazioneDB).where(StazioneDB.aperta), senza order_by | Nessun errore, ma il database non promette nessun ordine: le stazioni escono come sono state scritte (Porta Codice, Via Variabile, Largo Lista…), non in ordine alfabetico | test_stazioni_aperte_in_ordine_di_nome, test_stazioni_aperte_una_riga_intera |
return db.execute(domanda).all() | Arrivano le righe, non gli oggetti: ogni riga ha dentro un oggetto solo, e FastAPI non trova i campi: ResponseValidationError … Field required per nome, aperta, tornelli, id | tutti e quattro |
Un errore che non rompe niente. return db.scalars(domanda) senza .all() fa passare tutti i test: la rotta restituisce un ScalarResult e FastAPI lo scorre da solo. Non è sbagliato, ma non è una lista: non puoi contarla né stamparla. Tieni .all().
3 · Chi ha questo badge?
In italiano. Il badge è un testo che non è l'id: db.get non va bene. Scrivo una domanda («la persona con questo badge») e cerco una persona con db.scalar. Se non c'è, 404.
@app.get("/personale/{badge}")
def persona_per_badge(badge: str, db: Session = Depends(get_db)) -> Persona:
persona = db.scalar(select(PersonaDB).where(PersonaDB.badge == badge))
if persona is None:
raise HTTPException(status_code=404, detail="Persona non trovata")
return personaIl badge è unico (UNIQUE), quindi la domanda trova al massimo una persona: db.scalar è la mossa giusta. Con B-09 trova Ernesto Pozzi, che nel database è la riga con id 8: il numero del badge e l'id sono due cose diverse.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
persona = db.get(PersonaDB, badge) | db.get cerca per chiave primaria, che è un numero: DataError: (psycopg.errors.InvalidTextRepresentation) invalid input syntax for type integer: "B-07" | tutti e cinque |
select(Persona) (lo stampo al posto della classe-tabella) | ArgumentError: Column expression, FROM clause, or other columns clause element expected, got <class 'persona_per_badge.Persona'>. | tutti e cinque |
niente if persona is None | db.scalar dà None, la rotta lo restituisce: ResponseValidationError, 500 invece di 404 | test_persona_per_badge_uno_che_non_c_e_da_404 |
Un errore che non rompe niente. db.scalar dà la prima riga, anche se ce n'erano altre. Sul badge, che è unico, non fa differenza. Se cercassi per ruolo (che si ripete), ti darebbe una persona sola senza avvisarti: lì serve db.scalars(…).all().
4 · Un treno nuovo
In italiano.
- Con i dati arrivati costruisco un oggetto
TrenoDB. Non scrivo l'id: lo sceglie il database. - Lo metto nel carrello (
add). - Consegno il carrello (
commit): l'INSERTparte e viene confermato. - Riprendo l'oggetto dal database (
refresh), così ha l'ide tutti i suoi valori. - Lo restituisco: il decoratore dice che il codice è 201.
@app.post("/treni", status_code=status.HTTP_201_CREATED)
def nuovo_treno(dati: TrenoNuovo, db: Session = Depends(get_db)) -> Treno:
treno = TrenoDB(
codice=dati.codice,
vagoni=dati.vagoni,
km=dati.km,
in_servizio=dati.in_servizio,
stazione_id=dati.stazione_id,
)
db.add(treno)
db.commit()
db.refresh(treno)
return trenoPasso per passo.
| Riga | treno.id | Nel database |
|---|---|---|
treno = TrenoDB(…) | None | niente |
db.add(treno) | None | niente |
db.commit() | scelto dal database | la riga c'è |
db.refresh(treno) | 10 | la riga c'è |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente db.commit() (restano add e refresh) | Il refresh non trova niente da rileggere: InvalidRequestError: Instance '<TrenoDB at 0x…>' is not persistent within this Session, e il client riceve un 500 | tutti e quattro |
db.flush() al posto di db.commit() | Il flush manda il SQL ma non lo conferma: risposta 201 con l'id giusto, e nel database non c'è niente | test_treno_nuovo_e_nel_database, test_treno_nuovo_con_una_stazione |
TrenoDB(carrozze=dati.vagoni, …) | Una colonna che non esiste: TypeError: 'carrozze' is an invalid keyword argument for TrenoDB | tutti e quattro |
Il flush è la trappola da ricordare: l'unico test che la prende è quello che guarda dentro il database. Un test che controllasse solo la risposta passerebbe.
Un errore che non rompe niente. Togliere db.refresh(treno): i test restano verdi. Dopo il commit l'oggetto si ricarica da solo quando FastAPI ne legge gli attributi. Non è un errore, ma il refresh dice chiaramente cosa succede: tienilo.
5 · Sposta il treno
In italiano.
- Cerco il treno. Se non c'è, 404 «Treno non trovato».
- Se la nuova posizione è una stazione (non
None), controllo che la stazione esista. Se non c'è, 404 «Stazione non trovata». ConNoneil treno va al deposito: non c'è niente da controllare. - Cambio l'attributo
stazione_iddel treno, con il punto. commit: la sessione si accorge del cambiamento e scrive l'UPDATE.- Restituisco il treno.
@app.put("/treni/{treno_id}/stazione")
def sposta_treno(treno_id: int, dati: Spostamento, db: Session = Depends(get_db)) -> Treno:
treno = db.get(TrenoDB, treno_id)
if treno is None:
raise HTTPException(status_code=404, detail="Treno non trovato")
if dati.stazione_id is not None and db.get(StazioneDB, dati.stazione_id) is None:
raise HTTPException(status_code=404, detail="Stazione non trovata")
treno.stazione_id = dati.stazione_id
db.commit()
return trenoIl disegno.
Passo per passo.
| Richiesta | Cosa succede |
|---|---|
PUT /treni/9/stazione con {"stazione_id": 2} | trova il T28, trova la stazione 2, cambia l'attributo, commit, 200 |
PUT /treni/1/stazione con {"stazione_id": null} | trova il treno, salta il controllo (è None), cambia l'attributo, commit, 200 |
PUT /treni/99/stazione | db.get dà None: 404 «Treno non trovato» |
PUT /treni/9/stazione con {"stazione_id": 42} | trova il treno, ma db.get(StazioneDB, 42) dà None: 404 «Stazione non trovata», e il treno non si muove |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente db.commit() | La risposta è un 200 con il treno già spostato (l'oggetto in memoria è cambiato), ma il database non ne sa niente | test_sposta_treno_e_nel_database, test_sposta_treno_al_deposito |
| niente controllo della stazione | Il database rifiuta la stazione che non esiste: IntegrityError: (psycopg.errors.ForeignKeyViolation) insert or update on table "treni" violates foreign key constraint, Key (stazione_id)=(42) is not present in table "stazioni". Il client riceve un 500 invece del 404 | test_sposta_treno_in_una_stazione_che_non_c_e_da_404 |
il controllo anche con None (if db.get(StazioneDB, dati.stazione_id) is None) | db.get con None non trova nessuna stazione: il deposito diventa un 404 «Stazione non trovata» | test_sposta_treno_al_deposito |
La prima trappola è la più insidiosa: guardando solo la risposta, tutto sembra giusto. Il test che guarda nel database è rosso così:
E AssertionError: Lo spostamento non è nel database: c'è il db.commit()?
E assert [{'stazione_id': 6}] == [{'stazione_id': 2}]6 · La segnalazione sbagliata
In italiano. Cerco la segnalazione. Se non c'è, 404. Se c'è, la tolgo con db.delete e confermo con commit. Il 204 non ha corpo: niente return.
@app.delete("/segnalazioni/{segnalazione_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_segnalazione(segnalazione_id: int, db: Session = Depends(get_db)) -> None:
segnalazione = db.get(SegnalazioneDB, segnalazione_id)
if segnalazione is None:
raise HTTPException(status_code=404, detail="Segnalazione non trovata")
db.delete(segnalazione)
db.commit()db.delete vuole l'oggetto, non l'id: per questo prima c'è il db.get.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente db.commit() | Risposta 204, ma la riga non sparisce: il carrello della cancellazione non è mai partito | test_togli_segnalazione_e_sparita_dal_database, test_togli_segnalazione_le_altre_restano, test_togli_segnalazione_due_volte_la_seconda_da_404 |
niente if segnalazione is None | db.delete(None): UnmappedInstanceError: Class 'builtins.NoneType' is not mapped, e il client riceve un 500 invece del 404 | test_togli_segnalazione_che_non_c_e_da_404, test_togli_segnalazione_due_volte_la_seconda_da_404 |
7 · Il badge doppio
In italiano.
- Prima di scrivere, chiedo al database: «c'è già una persona con questo badge?». È un
db.scalarcon unwheresul badge. - Se c'è (non è
None), rispondo 409 e mi fermo: nienteadd. - Se non c'è, costruisco la persona,
add,commit,refresh. - La restituisco: il decoratore dice 201.
@app.post("/personale", status_code=status.HTTP_201_CREATED)
def nuova_persona(dati: PersonaNuova, db: Session = Depends(get_db)) -> Persona:
gemella = db.scalar(select(PersonaDB).where(PersonaDB.badge == dati.badge))
if gemella is not None:
raise HTTPException(status_code=409, detail="Badge già usato da un'altra persona")
persona = PersonaDB(
badge=dati.badge,
nome=dati.nome,
ruolo=dati.ruolo,
stazione_id=dati.stazione_id,
)
db.add(persona)
db.commit()
db.refresh(persona)
return personaIl controllo è sul badge, non sul nome: due persone con lo stesso nome possono esistere (c'è già una Marta Villa, e c'è anche un'altra Villa, Paolo). Il badge no: è UNIQUE nel database.
Il disegno.
Passo per passo.
| Richiesta | Il controllo | Il risultato |
|---|---|---|
badge B-20, nome «Anna Neri» | gemella è None | add, commit, refresh: 201, id 13 |
badge B-09 | trova Ernesto Pozzi | 409, niente scritto |
badge B-20, nome «Marta Villa» | gemella è None (il badge non c'è) | 201: il nome doppio non è un problema |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| niente controllo | Il 409 lo dà il database, a modo suo: IntegrityError: (psycopg.errors.UniqueViolation) duplicate key value violates unique constraint "personale_badge_key", Key (badge)=(B-09) already exists. Il client riceve un 500 | test_persona_nuova_badge_doppio_da_409 |
controllo sul nome (PersonaDB.nome == dati.nome) | Un badge già usato, con un nome diverso, passa il controllo e arriva fino al database (stessa IntegrityError). Una seconda Marta Villa con un badge nuovo, che andrebbe bene, prende un 409 | test_persona_nuova_badge_doppio_da_409, test_persona_nuova_due_con_lo_stesso_nome_si_puo |
Il vincolo UNIQUE del database è l'ultima difesa: anche senza il controllo, il badge doppio non entra mai. Il controllo serve per rispondere come si deve, con un 409 che dice cosa è successo.
La storia
La storia usa un file solo, storia/archivio.py. Prima delle rotte, un pezzo che serve a più livelli: cercare un caso dal numero di fascicolo, o dare il 404.
def trova_caso(fascicolo: str, db: Session) -> CasoDB:
caso = db.scalar(select(CasoDB).where(CasoDB.fascicolo == fascicolo))
if caso is None:
raise HTTPException(status_code=404, detail="Fascicolo non trovato")
return casoLivello 1 · Tutti i fascicoli
In italiano. Una domanda sola: tutti i casi, in ordine di fascicolo. La eseguo con scalars e all.
@app.get("/casi")
def lista_casi(db: Session = Depends(get_db)) -> list[Caso]:
return db.scalars(select(CasoDB).order_by(CasoDB.fascicolo)).all()Questa è la versione di Nadia con la sessione. Il suo SQL (SELECT * FROM casi ORDER BY fascicolo) è diventato select(CasoDB).order_by(CasoDB.fascicolo): stessa domanda, scritta con le classi.
Livello 2 · Un fascicolo, dal suo numero
In italiano. Il numero di fascicolo (F-25-04) è un testo, non l'id: serve un where, non un get. Cerco con db.scalar; se è None, 404.
@app.get("/casi/{fascicolo}")
def leggi_caso(fascicolo: str, db: Session = Depends(get_db)) -> Caso:
return trova_caso(fascicolo, db)Il controllo sta in trova_caso (sopra), che serve anche ai livelli 3 e 4. Nel registro vero, GET /casi/F-25-04 risponde:
$ curl -s http://127.0.0.1:8000/casi/F-25-04
{"id":5,"fascicolo":"F-25-04","titolo":"Le monete di Largo Lista","stazione":"Largo Lista","anno":2025,"aperto":true}Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
db.get(CasoDB, fascicolo) in trova_caso | db.get cerca per id, un numero: DataError: (psycopg.errors.InvalidTextRepresentation) invalid input syntax for type integer: "P-02" | i dieci test dei livelli 2, 3 e 4 (tutti passano da trova_caso) |
Livello 3 · Gli indizi di un caso
In italiano. Trovo il caso (404 se non c'è), poi cerco gli indizi con quel caso_id, dal più vecchio: prima per data, poi per id, così due indizi della stessa notte escono sempre nello stesso ordine.
@app.get("/casi/{fascicolo}/indizi")
def lista_indizi(fascicolo: str, db: Session = Depends(get_db)) -> list[Indizio]:
caso = trova_caso(fascicolo, db)
domanda = select(IndizioDB).where(IndizioDB.caso_id == caso.id).order_by(IndizioDB.data, IndizioDB.id)
return db.scalars(domanda).all()Con gli indizi veri, per il caso aperto (le stesse righe che dà la rotta, viste da psql):
$ psql -d db_sessione -c "SELECT id, data, badge FROM indizi WHERE caso_id = 5 ORDER BY data, id"
id | data | badge
----+------------+-------
1 | 2025-10-06 | B-12
2 | 2025-10-06 | B-11
3 | 2025-10-06 | B-06
4 | 2025-10-06 | B-04
5 | 2025-10-13 | B-06
6 | 2025-10-13 | B-11
7 | 2025-10-13 | B-05
8 | 2025-10-20 | B-12
9 | 2025-10-20 | B-06
10 | 2025-10-20 | B-06
11 | 2025-10-20 | B-11
12 | 2025-10-20 | B-01
13 | 2025-10-27 | B-11
14 | 2025-10-27 | B-05
(14 righe)Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente order_by | Nessun errore: gli indizi escono nell'ordine in cui sono stati scritti, che non è quello delle date | test_livello_3_gli_indizi_dal_piu_vecchio |
Livello 4 · Un indizio nuovo
In italiano. Trovo il caso (404 se non c'è). Costruisco un IndizioDB con il caso_id del caso trovato e i dati arrivati. add, commit, refresh: 201.
@app.post("/casi/{fascicolo}/indizi", status_code=status.HTTP_201_CREATED)
def nuovo_indizio(fascicolo: str, dati: IndizioNuovo, db: Session = Depends(get_db)) -> Indizio:
caso = trova_caso(fascicolo, db)
indizio = IndizioDB(caso_id=caso.id, data=dati.data, badge=dati.badge, nota=dati.nota)
db.add(indizio)
db.commit()
db.refresh(indizio)
return indizioIl caso_id non arriva nel corpo: lo ricavi dal caso, che hai già in mano. Il corpo di Mapelli è l'indizio del 27 ottobre: nella risposta compare con l'id 15.
Livello 5 · Un indizio ricopiato male
In italiano. Cerco l'indizio dall'id (404 se non c'è). Cambio i tre attributi con quelli arrivati, commit, lo restituisco. Il caso_id non si tocca.
@app.put("/indizi/{indizio_id}")
def correggi_indizio(indizio_id: int, dati: IndizioNuovo, db: Session = Depends(get_db)) -> Indizio:
indizio = db.get(IndizioDB, indizio_id)
if indizio is None:
raise HTTPException(status_code=404, detail="Indizio non trovato")
indizio.data = dati.data
indizio.badge = dati.badge
indizio.nota = dati.nota
db.commit()
return indizioPer trovare quale indizio correggere guardi la lista del livello 3: il 13 ottobre c'è un B-11 con id 6, e Mapelli dice che doveva essere B-12.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente db.commit() | La risposta mostra il badge già corretto (l'oggetto in memoria è cambiato), ma l'archivio non cambia: al prossimo GET il B-11 è ancora lì | test_livello_5_la_correzione_e_nel_database |
Livello 6 · Un indizio di troppo
In italiano. Cerco l'indizio dall'id (404 se non c'è), lo tolgo con db.delete, commit. Il 204 non ha corpo.
@app.delete("/indizi/{indizio_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_indizio(indizio_id: int, db: Session = Depends(get_db)) -> None:
indizio = db.get(IndizioDB, indizio_id)
if indizio is None:
raise HTTPException(status_code=404, detail="Indizio non trovato")
db.delete(indizio)
db.commit()Il doppione è nel registro come due righe uguali, il 20 ottobre, con B-06: gli id 9 e 10. Ne togli uno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
niente if indizio is None | db.delete(None): UnmappedInstanceError: Class 'builtins.NoneType' is not mapped, 500 invece del 404 | test_livello_6_un_indizio_che_non_c_e |
Il finale
Il ragionamento. Per ogni badge, conti in quante notti diverse compare. Lo fai con una psql (ma potevi farlo a occhio, dalla lista del livello 3):
psql -d db_sessione -c "SELECT badge, count(DISTINCT data) AS notti, count(*) AS indizi FROM indizi GROUP BY badge ORDER BY notti DESC, badge"Questo è l'archivio come lo trovi, prima dei ritocchi:
badge | notti | indizi
-------+-------+--------
B-11 | 4 | 4
B-06 | 3 | 4
B-05 | 2 | 2
B-12 | 2 | 2
B-01 | 1 | 1
B-04 | 1 | 1
(6 righe)B-11 sembra l'unico presente tutte e quattro le notti (4). Sbagliato: guarda il cartoncino del 13 ottobre. Questa è la pista di Gino D'Alessio, e il commissario risponde:
$ python storia/verifica.py "Gino D'Alessio"
Il commissario Mapelli scuote la testa: «No.»
Rileggi il cartoncino del 13 ottobre: il badge era davvero quello? Guarda il livello 5.Dopo il livello 4 (l'indizio del 27 ottobre, B-12), B-12 sale a 3 notti:
badge | notti | indizi
-------+-------+--------
B-11 | 4 | 4
B-06 | 3 | 4
B-12 | 3 | 3
B-05 | 2 | 2
B-01 | 1 | 1
B-04 | 1 | 1
(6 righe)Dopo il livello 5 (il B-11 del 13 ottobre diventa B-12), B-12 ha 4 notti, B-11 scende a 3. Ma attenzione alla colonna indizi: B-06 ha 4 indizi in 3 notti.
badge | notti | indizi
-------+-------+--------
B-12 | 4 | 4
B-06 | 3 | 4
B-11 | 3 | 3
B-05 | 2 | 2
B-01 | 1 | 1
B-04 | 1 | 1
(6 righe)Chi conta le righe invece delle notti si ferma a Pietro Galli, e il commissario risponde:
$ python storia/verifica.py "Pietro Galli"
Il commissario Mapelli scuote la testa: «No.»
Lo stai contando due volte, quel nome: c'è un cartoncino ricopiato in doppio. Guarda il livello 6.Dopo il livello 6 (il doppione del 20 ottobre se ne va), B-06 ha 3 indizi, e non c'è più niente da confondere:
badge | notti | indizi
-------+-------+--------
B-12 | 4 | 4
B-06 | 3 | 3
B-11 | 3 | 3
B-05 | 2 | 2
B-01 | 1 | 1
B-04 | 1 | 1
(6 righe)L'unico badge con 4 notti è B-12. Di chi è?
$ psql -d db_sessione -c "SELECT nome, ruolo FROM personale WHERE badge = 'B-12'"
nome | ruolo
----------------+----------------------------
Fabio Cattaneo | tecnico delle scale mobili
(1 riga)La risposta è Fabio Cattaneo, il tecnico delle scale mobili di Ponte Ciclo: il lunedì notte fa la manutenzione anche a Largo Lista, e non ha mai fatto una segnalazione, quindi nessuno gli aveva mai chiesto niente. Mapelli lo scopre solo perché le tre piste sbagliate sono cadute una dopo l'altra:
- senza il livello 4, B-12 ha 3 notti, come B-06 e B-11: tre nomi a pari merito;
- senza il livello 5, sembra B-11, Gino D'Alessio;
- senza il livello 6, un doppione fa contare B-06 due volte.
$ python storia/verifica.py "Fabio Cattaneo"
Il commissario Mapelli annuisce, piano.
«Il lunedì notte fa la manutenzione anche a Largo Lista, e nessuno gli aveva mai chiesto niente.
Domani gli porto un caffè e due domande.»
Pista trovata.