CRUD su un dizionario, 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 quasi tutti i test e si rompono su uno solo.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
Negli zip le soluzioni sono file completi: li trovi in palestra/ e in storia/, con lo stesso nome dei tuoi.
La palestra
1 · Gli oggetti smarriti
In italiano.
- Se nella richiesta non c'è la stazione, restituisco tutti gli oggetti.
- Altrimenti parto da una lista vuota.
- Guardo gli oggetti uno per uno: se è della stazione cercata, lo metto nella lista.
- Alla fine restituisco la lista (anche se è vuota).
@app.get("/oggetti")
def lista_oggetti(stazione_id: int | None = None) -> list[Oggetto]:
if stazione_id is None:
return list(oggetti.values())
trovati = []
for oggetto in oggetti.values():
if oggetto.stazione_id == stazione_id:
trovati.append(oggetto)
return trovatiIl disegno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Niente if stazione_id is None: si va dritti al for | Senza filtro, stazione_id vale None e nessun oggetto ha la stazione None: la lista è sempre vuota | test_senza_filtro_tutti_gli_oggetti |
return trovati dentro il for (rientrato sotto l'if) | Dopo il primo giro la funzione restituisce quello che ha: con il filtro 5, il primo oggetto è della stazione 1 e la lista è vuota | test_con_il_filtro_solo_quella_stazione |
Dopo il for: if not trovati: raise HTTPException(status_code=404, …) | Nessun oggetto trovato diventa un errore. Ma «nessuno» è una risposta giusta: 200 e [] | test_nessun_oggetto_e_una_lista_vuota |
La seconda è la più subdola: il codice sembra giusto, e funziona quando il primo oggetto della lista passa il filtro. Il return vive nell'indentazione: sta allineato al for (una volta, alla fine), non sotto di lui.
2 · I turni del personale
In italiano. Chiedo il turno con get. Se la risposta è None, il turno non c'è: lancio il 404. Altrimenti lo restituisco.
@app.get("/turni/{turno_id}")
def leggi_turno(turno_id: int) -> Turno:
turno = turni.get(turno_id)
if turno is None:
raise HTTPException(status_code=404, detail="Turno non trovato")
return turnoLe trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return turni[turno_id] | Con il turno 4 (che non c'è): KeyError: 4. Nel server vero è un 500 | test_turno_che_non_esiste |
return HTTPException(status_code=404, …) | return consegna l'eccezione come se fosse il turno: FastAPI prova a trattarla da Turno e va in errore (ResponseValidationError, che nel server vero è un 500). Per fermare tutto si lancia: raise | test_turno_che_non_esiste |
Un for sui turni con if turno.id == turno_id: return turno e un else: raise HTTPException(…) sotto | L'else è dello if, dentro il for: al primo turno che non è quello cercato, parte il 404. Il turno 3 non viene mai raggiunto | test_un_turno, test_l_ultimo_turno |
Il get fa già il lavoro del for: il dizionario trova la chiave da solo, senza scorrere i turni. È a questo che serve avere l'id come chiave.
3 · Le segnalazioni dei guasti
In italiano.
- Scelgo l'id nuovo con
prossimo_id(segnalazioni). - Costruisco la
Segnalazionecon quell'id e i dati arrivati. - La metto nel dizionario, alla chiave del suo id.
- La restituisco. Il 201 sta nel decoratore.
@app.post("/segnalazioni", status_code=status.HTTP_201_CREATED)
def nuova_segnalazione(dati: SegnalazioneNuova) -> Segnalazione:
segnalazione = Segnalazione(
id=prossimo_id(segnalazioni),
treno=dati.treno,
testo=dati.testo,
gravita=dati.gravita,
)
segnalazioni[segnalazione.id] = segnalazione
return segnalazionePasso per passo. Il dizionario ha gli id 1, 2 e 4 (la 3 è stata chiusa). POST /segnalazioni con {"treno": "M14", "testo": "aria condizionata rotta", "gravita": 2}:
| Riga | Cosa fa | Cosa c'è dopo |
|---|---|---|
prossimo_id(segnalazioni) | Il più grande id è 4, più uno | 5 |
Segnalazione(id=5, …) | Costruisce la scatola nuova, con i dati del corpo | un oggetto con l'id 5 |
segnalazioni[segnalazione.id] = segnalazione | La mette nel dizionario, alla chiave 5 | chiavi 1, 2, 4, 5 |
return segnalazione | FastAPI la trasforma in JSON, con il 201 del decoratore | 201 e la segnalazione |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
@app.post("/segnalazioni"), senza lo status_code | Funziona, ma risponde 200: «va tutto bene» e non «creato». I 201 dicono al client che qualcosa di nuovo esiste | test_una_segnalazione_nuova |
id=len(segnalazioni) + 1 | Le segnalazioni sono tre, 3 più 1 fa 4: ma il 4 c'è già, e viene sovrascritto. Una segnalazione sparisce, e nessuno se ne accorge | test_una_segnalazione_nuova, test_la_segnalazione_resta_nell_archivio, test_dopo_la_post_la_lista_ne_ha_una_in_piu, test_due_segnalazioni_di_fila |
segnalazioni[segnalazione.id] = dati | Nel dizionario finisce dati, il corpo senza id, al posto della segnalazione. La risposta della POST è giusta, ma l'archivio è rotto | test_la_segnalazione_resta_nell_archivio, test_dopo_la_post_la_lista_ne_ha_una_in_piu |
La seconda è il guaio classico: con un dizionario senza buchi (1, 2, 3) funziona benissimo, e i test «normali» non la trovano. Per questo i dati dello zip hanno un buco.
4 · I tornelli
In italiano.
- Prima il 404: se il tornello non c'è, la funzione si ferma (
trova_tornellolo fa). - Costruisco un
Tornellonuovo: l'id dal percorso, tutto il resto dal corpo. - Lo metto al posto del vecchio, alla stessa chiave.
- Lo restituisco.
@app.put("/tornelli/{tornello_id}")
def sostituisci_tornello(tornello_id: int, dati: TornelloNuovo) -> Tornello:
trova_tornello(tornello_id) # prima il 404: se non c'è, la funzione si ferma qui
tornello = Tornello(
id=tornello_id,
stazione_id=dati.stazione_id,
stato=dati.stato,
passaggi=dati.passaggi,
)
tornelli[tornello_id] = tornello
return tornelloPasso per passo. PUT /tornelli/2 con {"stazione_id": 1, "stato": "aperto", "passaggi": 310}:
| Riga | Cosa fa | Il dizionario tornelli |
|---|---|---|
trova_tornello(2) | Il 2 c'è: niente errore, si va avanti | invariato |
Tornello(id=2, …) | Una scatola nuova, con aperto e 310 | invariato (la scatola nuova è ancora fuori) |
tornelli[2] = tornello | La chiave 2 punta alla scatola nuova; la vecchia (guasto, 300) non ha più etichetta | chiavi 1, 2, 3, con il 2 cambiato |
Con il 9, la prima riga lancia il 404 e le altre non girano mai.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Niente trova_tornello | Con l'id 9 la PUT crea il tornello 9 (tornelli[9] = … aggiunge una chiave nuova) e risponde 200. Un tornello che nessuno ha montato | test_tornello_che_non_esiste |
Il controllo (if tornello_id not in tornelli: raise …) dopo tornelli[tornello_id] = tornello | Quando arriva il controllo, il 9 ormai c'è: il 404 non parte più. Il lavoro è già stato fatto. Prima il 404, poi il lavoro | test_tornello_che_non_esiste |
vecchio = trova_tornello(…), poi vecchio.stato = dati.stato e return vecchio | Cambia solo lo stato e dimentica gli altri campi: la stazione e i passaggi restano com'erano. Non è una sostituzione, è un ritocco (quello è il PATCH) | test_sostituisce_il_tornello, test_il_tornello_nuovo_e_nel_dizionario |
5 · Gli annunci
In italiano.
- Se l'id non è tra le chiavi del dizionario, 404.
- Altrimenti tolgo la chiave (e la sua scatola) con
del. - Niente
return: il 204 non ha corpo.
@app.delete("/annunci/{annuncio_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_annuncio(annuncio_id: int) -> None:
if annuncio_id not in annunci:
raise HTTPException(status_code=404, detail="Annuncio non trovato")
del annunci[annuncio_id]Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il decoratore senza status_code=status.HTTP_204_NO_CONTENT | L'annuncio viene tolto, ma la risposta è 200 (con null come corpo) invece di 204 | test_togli_un_annuncio |
Solo del annunci[annuncio_id], senza il controllo | Con un id che non c'è, del dà KeyError: nel server vero un 500, invece del 404 | test_la_seconda_volta_404, test_annuncio_che_non_esiste |
if annuncio_id not in annunci.values(): | in sui valori cerca un numero tra gli oggetti Annuncio: non lo trova mai. Ogni DELETE risponde 404, e niente viene tolto | test_togli_un_annuncio, test_l_annuncio_non_c_e_piu |
in su un dizionario guarda le chiavi (è la regola di I dizionari), e qui le chiavi sono gli id: è esattamente quello che serve.
6 · L'ufficio badge
In italiano.
codice_gia_usatoguarda tutti i badge. Se ne trova uno diverso datranne_idcon quel codice, rispondeTrue. Se finisce il giro senza trovarlo,False.- Nella POST: se il codice è già usato, 409. Poi il lavoro di sempre.
- Nella PUT: stesso controllo, ma con
tranne_id=badge_id, per non rifiutare il badge che tiene il suo codice.
def codice_gia_usato(codice: str, tranne_id: int | None = None) -> bool:
for altro in badge.values():
if altro.codice == codice and altro.id != tranne_id:
return True
return False@app.post("/badge", status_code=status.HTTP_201_CREATED)
def nuovo_badge(dati: BadgeNuovo) -> Badge:
if codice_gia_usato(dati.codice):
raise HTTPException(status_code=409, detail="Codice già usato da un altro badge")
nuovo = Badge(id=prossimo_id(badge), codice=dati.codice, nome=dati.nome, ruolo=dati.ruolo)
badge[nuovo.id] = nuovo
return nuovo
@app.put("/badge/{badge_id}")
def sostituisci_badge(badge_id: int, dati: BadgeNuovo) -> Badge:
trova_badge(badge_id) # prima il 404
if codice_gia_usato(dati.codice, tranne_id=badge_id):
raise HTTPException(status_code=409, detail="Codice già usato da un altro badge")
nuovo = Badge(id=badge_id, codice=dati.codice, nome=dati.nome, ruolo=dati.ruolo)
badge[badge_id] = nuovo
return nuovoPasso per passo. PUT /badge/4 con il codice B-04 (il suo). Dentro codice_gia_usato("B-04", tranne_id=4):
| Giro | altro | altro.codice == "B-04"? | altro.id != 4? | Tutte e due? |
|---|---|---|---|---|
| 1 | badge 1 (B-01) | no | sì | no |
| 2 | badge 2 (B-02) | no | sì | no |
| 3 | badge 3 (B-03) | no | sì | no |
| 4 | badge 4 (B-04) | sì | no | no |
Nessun giro è «sì e sì»: il for finisce, e la funzione risponde False. Niente 409: il badge 4 tiene il suo codice. Con il codice B-02 (di Ivo Brambati): il giro 2 è «sì e sì», return True, e la PUT risponde 409.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return False dentro il for (rientrato sotto l'if) | Il primo badge che non ha quel codice fa già rispondere «no»: si guarda solo il badge 1. I codici degli altri non sono mai confrontati | test_un_codice_gia_usato, test_tranne_se_stesso, test_post_con_un_codice_gia_usato, test_put_con_il_codice_di_un_altro |
return codice in badge | in guarda le chiavi, e le chiavi sono gli id (1, 2, 3, 4): "B-03" non c'è mai. Nessun codice è mai «già usato» | test_un_codice_gia_usato, test_tranne_se_stesso, test_post_con_un_codice_gia_usato, test_put_con_il_codice_di_un_altro |
if altro.codice == codice: senza altro.id != tranne_id | Il badge 4 che tiene il suo codice si trova in conflitto con sé stesso: la PUT risponde 409 | test_tranne_se_stesso, test_put_che_tiene_il_suo_codice |
| Il controllo con il 409 solo nella POST, non nella PUT | Un badge nuovo non può avere un codice doppio, ma un badge che esiste sì: basta riscriverlo con una PUT | test_put_con_il_codice_di_un_altro |
La seconda ricorda la differenza tra la chiave (l'id) e quello che c'è dentro (il codice). Per cercare un valore si scorrono i valori.
7 · Le biciclette di Ponte Ciclo
In italiano. Le cinque rotte, nell'ordine. Una funzione trova_bicicletta fa il 404 e serve a tre rotte. La lista ha due filtri facoltativi: per ogni bicicletta, una domanda per filtro («il filtro non c'è, oppure la bicicletta lo rispetta»), e passa se le domande sono vere tutte e due.
@app.get("/biciclette")
def lista_biciclette(stazione_id: int | None = None, libera: bool | None = None) -> list[Bicicletta]:
trovate = []
for bicicletta in biciclette.values():
passa_stazione = stazione_id is None or bicicletta.stazione_id == stazione_id
passa_libera = libera is None or bicicletta.libera == libera
if passa_stazione and passa_libera:
trovate.append(bicicletta)
return trovate
def trova_bicicletta(bicicletta_id: int) -> Bicicletta:
"""La bicicletta con quell'id. Se non c'è, si ferma tutto con il 404."""
bicicletta = biciclette.get(bicicletta_id)
if bicicletta is None:
raise HTTPException(status_code=404, detail="Bicicletta non trovata")
return bicicletta
@app.get("/biciclette/{bicicletta_id}")
def leggi_bicicletta(bicicletta_id: int) -> Bicicletta:
return trova_bicicletta(bicicletta_id)
@app.post("/biciclette", status_code=status.HTTP_201_CREATED)
def nuova_bicicletta(dati: BiciclettaNuova) -> Bicicletta:
bicicletta = Bicicletta(
id=prossimo_id(biciclette),
stazione_id=dati.stazione_id,
libera=dati.libera,
elettrica=dati.elettrica,
)
biciclette[bicicletta.id] = bicicletta
return bicicletta
@app.put("/biciclette/{bicicletta_id}")
def sostituisci_bicicletta(bicicletta_id: int, dati: BiciclettaNuova) -> Bicicletta:
trova_bicicletta(bicicletta_id) # prima il 404
bicicletta = Bicicletta(
id=bicicletta_id,
stazione_id=dati.stazione_id,
libera=dati.libera,
elettrica=dati.elettrica,
)
biciclette[bicicletta_id] = bicicletta
return bicicletta
@app.delete("/biciclette/{bicicletta_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_bicicletta(bicicletta_id: int) -> None:
trova_bicicletta(bicicletta_id) # prima il 404
del biciclette[bicicletta_id]Il disegno.
Passo per passo. GET /biciclette?stazione_id=4&libera=true. I due filtri valgono 4 e True:
| Bicicletta | passa_stazione | passa_libera | Passa? |
|---|---|---|---|
| 1 (stazione 4, libera) | sì | sì | sì |
| 2 (stazione 4, in uso) | sì | no | no |
| 3 (stazione 1, libera) | no | sì | no |
| 5 (stazione 4, libera) | sì | sì | sì |
La lista che torna: 1 e 5. Con un filtro solo (libera=false, cioè False), stazione_id vale None: passa_stazione è vera per tutte («il filtro non c'è»), e decide solo passa_libera. Con nessun filtro, tutte e due le domande sono vere per tutte, e tornano tutte le biciclette: non serve nemmeno un caso a parte.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Un if solo, if bicicletta.stazione_id == stazione_id and bicicletta.libera == libera: (dopo il caso «nessun filtro») | Con un solo filtro, l'altro vale None e nessuna bicicletta ha il valore None: la lista è vuota. Funziona solo quando i filtri sono tutti e due presenti | test_lista_di_una_stazione, test_lista_solo_le_libere, test_lista_solo_quelle_in_uso |
passa_libera = not libera or bicicletta.libera == libera | not libera è vero anche per False: libera=false viene scambiato per «nessun filtro», e tornano tutte le biciclette | test_lista_solo_quelle_in_uso |
def leggi_bicicletta(id: int) con il percorso /biciclette/{bicicletta_id} | Il nome nel def non è tra le graffe: FastAPI lo prende per un parametro di query, obbligatorio, e risponde 422 a ogni richiesta con il solo id nel percorso | test_leggi_una_bicicletta, test_leggi_una_bicicletta_che_non_esiste |
La seconda è il cugino di if stazione_id: della teoria: la domanda giusta è sempre is None, mai «è vero?».
La storia · La centrale della Linea Menta
Le rotte dei sette livelli, nel file storia/centrale.py. Gli esempi già fatti (trova_treno e GET /treni/{treno_id}) restano com'erano.
Livello 1 · Le stazioni aperte
In italiano. Lista vuota, for sulle stazioni, se è aperta la metto nella lista.
@app.get("/stazioni")
def lista_stazioni() -> list[Stazione]:
aperte = []
for stazione in stazioni.values():
if stazione.aperta:
aperte.append(stazione)
return aperteLivello 2 · Una stazione
In italiano. Lo schema di trova_treno, sul dizionario delle stazioni. Anche le stazioni chiuse si trovano: Vecchia Fiera ha un id.
@app.get("/stazioni/{stazione_id}")
def leggi_stazione(stazione_id: int) -> Stazione:
stazione = stazioni.get(stazione_id)
if stazione is None:
raise HTTPException(status_code=404, detail="Stazione non trovata")
return stazioneLivello 3 · I treni, con un filtro
In italiano. Senza tipo, tutti i treni. Con tipo, il setaccio.
@app.get("/treni")
def lista_treni(tipo: str | None = None) -> list[Treno]:
if tipo is None:
return list(treni.values())
trovati = []
for treno in treni.values():
if treno.tipo == tipo:
trovati.append(treno)
return trovatiLivello 4 · I treni di una stazione
In italiano. Prima il 404 della stazione, e per averlo chiamo la rotta del livello 2 come una funzione. Poi il setaccio, sui treni fermi lì.
@app.get("/stazioni/{stazione_id}/treni")
def treni_della_stazione(stazione_id: int) -> list[Treno]:
leggi_stazione(stazione_id) # il livello 2: se la stazione non c'è, il 404 parte da lì
fermi = []
for treno in treni.values():
if treno.stazione_id == stazione_id:
fermi.append(treno)
return fermiLivello 5 · L'M30 entra in rete
In italiano. L'id con prossimo_id, il treno con quell'id, nel dizionario, restituito. 201 nel decoratore.
@app.post("/treni", status_code=status.HTTP_201_CREATED)
def nuovo_treno(dati: TrenoNuovo) -> Treno:
treno = Treno(
id=prossimo_id(treni),
codice=dati.codice,
tipo=dati.tipo,
vagoni=dati.vagoni,
stazione_id=dati.stazione_id,
guasto=dati.guasto,
)
treni[treno.id] = treno
return trenoLivello 6 · I treni guasti vanno al Deposito
In italiano. Prima il 404, poi una scatola nuova alla stessa chiave: l'id dal percorso, tutto il resto dal corpo.
@app.put("/treni/{treno_id}")
def sostituisci_treno(treno_id: int, dati: TrenoNuovo) -> Treno:
trova_treno(treno_id) # prima il 404
treno = Treno(
id=treno_id,
codice=dati.codice,
tipo=dati.tipo,
vagoni=dati.vagoni,
stazione_id=dati.stazione_id,
guasto=dati.guasto,
)
treni[treno_id] = treno
return trenoLivello 7 · Via il treno di servizio
In italiano. Prima il 404, poi del. Niente return: il 204 non ha corpo.
@app.delete("/treni/{treno_id}", status_code=status.HTTP_204_NO_CONTENT)
def togli_treno(treno_id: int) -> None:
trova_treno(treno_id) # prima il 404
del treni[treno_id]Il finale
Le quattro cifre, lette sulla rete com'era alle 4:30:
| Livello | La domanda | Cosa risponde la rete |
|---|---|---|
| 1 | Quante stazioni sono aperte? | 5 (Porta Codice, Via Variabile, Largo Lista, Ponte Ciclo, Piazza Query) |
| 2 | L'id di Vecchia Fiera | 6 |
| 3 | Quanti tram ci sono? | 4 (T05, T09, T28, T31) |
| 4 | Quanti treni sono fermi a Vecchia Fiera? | 3 (S01, M18, T28) |
Le cifre del mattino: 5643.
Il piano:
- livello 5: la POST dell'M30 a Vecchia Fiera (stazione 6);
- livello 6: i due treni guasti sono T09 (id 5, porte bloccate) e M18 (id 8, freni da controllare): PUT con
stazione_ida 7, e tutto il resto com'era,guastocompreso; - livello 7: il treno di servizio che occupa Vecchia Fiera è S01 (id 6): DELETE.
(Il T28 è a Vecchia Fiera, ma non è di servizio e non è guasto: resta dov'è. L'S02 è già al Deposito.)
Poi POST /sala-controllo/via-libera con {"cifre": "5643"}. Lo stesso piano, fatto da Python con la rete vera (è il file storia/piano.py delle soluzioni, lanciato con python3 storia/piano.py):
1 · GET /stazioni -> 5 stazioni aperte
2 · GET /stazioni/{id}, un id alla volta -> Vecchia Fiera è la 6
3 · GET /treni?tipo=tram -> 4 tram
4 · GET /stazioni/6/treni -> 3 treni fermi a Vecchia Fiera
Le cifre: 5643
5 · POST /treni -> 201 {'codice': 'M30', 'tipo': 'metro', 'vagoni': 6, 'stazione_id': 6, 'guasto': None, 'id': 12}
6 · PUT /treni/5 -> 200 {'codice': 'T09', 'tipo': 'tram', 'vagoni': 1, 'stazione_id': 7, 'guasto': 'porte bloccate', 'id': 5}
6 · PUT /treni/8 -> 200 {'codice': 'M18', 'tipo': 'metro', 'vagoni': 4, 'stazione_id': 7, 'guasto': 'freni da controllare', 'id': 8}
7 · DELETE /treni/6 -> 204
POST /sala-controllo/via-libera -> 200 {'messaggio': "Via libera: alle 6:00 l'M30 parte da Vecchia Fiera."}Nota l'id del treno nuovo: 12. I treni della notte arrivano all'11 (con il 7 rottamato): con prossimo_id il nuovo prende il 12, con «quanti sono più uno» avrebbe preso l'11, e avrebbe cancellato l'S02.
Le trappole della storia.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Livello 1: return list(stazioni.values()), senza if | Le stazioni chiuse (Vecchia Fiera, il Deposito) compaiono nella lista: la prima cifra è sbagliata | test_livello_1_solo_le_stazioni_aperte, test_livello_1_nessuna_stazione_aperta |
Livello 2: if stazione is None or not stazione.aperta: | Una stazione chiusa risponde 404 come se non esistesse. Ma Vecchia Fiera è chiusa, e ti serve proprio quella. Il livello 4 si rompe di conseguenza per le stazioni chiuse | test_livello_2_anche_una_stazione_chiusa, test_livello_4_una_stazione_senza_treni |
Livello 3: il for senza il ramo if tipo is None | Senza ?tipo=, tipo vale None e nessun treno ha il tipo None: GET /treni risponde sempre [] | test_livello_3_senza_filtro_tutti_i_treni |
Livello 4: niente leggi_stazione(stazione_id) | Una stazione che non c'è non risponde 404: il setaccio non trova treni e restituisce [] | test_livello_4_stazione_che_non_esiste |
Livello 5: id=len(treni) + 1 | In rete ci sono dieci treni, ma gli id arrivano all'11: il nuovo prende l'id 11 e sovrascrive un treno che c'è già | test_livello_5_un_treno_nuovo, test_livello_5_il_treno_resta_in_rete |
Livello 5: manca treni[treno.id] = treno | La risposta è giusta, ma il treno non è nel dizionario: la sala controllo non lo vede mai | test_livello_5_il_treno_resta_in_rete |
Livello 6: niente trova_treno | Una PUT su un id che non c'è crea un treno dal nulla, con 200 invece del 404 | test_livello_6_treno_che_non_esiste |
Livello 7: solo del treni[treno_id] | Un id che non c'è, o la seconda volta, dà KeyError: un 500 invece del 404 | test_livello_7_la_seconda_volta_404, test_livello_7_treno_che_non_esiste |