Vai al contenuto
code-to-code

Apro l'indice…

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

HTTP e API7. CRUD su un dizionariop. 208

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.

http-crud-su-un-dizionario-soluzioni.zip32 KB

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.

  1. Se nella richiesta non c'è la stazione, restituisco tutti gli oggetti.
  2. Altrimenti parto da una lista vuota.
  3. Guardo gli oggetti uno per uno: se è della stazione cercata, lo metto nella lista.
  4. Alla fine restituisco la lista (anche se è vuota).
Python
@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 trovati

Il disegno.

inizio GET /oggetti se stazione_id is None sì: restituisci tutti gli oggetti trovati = [] per ogni oggetto in oggetti.values() se oggetto.stazione_id == stazione_id sì: trovati.append(oggetto) restituisci trovatiGET /oggettistazione_id is Nonerestituisci tutti glioggettitrovati = []per ogni oggetto inoggetti.values()oggetto.stazione_id== stazione_idtrovati.append(oggetto)restituisci trovatinosìnosìfiniti
Gli oggetti, con o senza filtro

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
Niente if stazione_id is None: si va dritti al forSenza filtro, stazione_id vale None e nessun oggetto ha la stazione None: la lista è sempre vuotatest_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 è vuotatest_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.

Python
@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 turno

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
return turni[turno_id]Con il turno 4 (che non c'è): KeyError: 4. Nel server vero è un 500test_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: raisetest_turno_che_non_esiste
Un for sui turni con if turno.id == turno_id: return turno e un else: raise HTTPException(…) sottoL'else è dello if, dentro il for: al primo turno che non è quello cercato, parte il 404. Il turno 3 non viene mai raggiuntotest_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.

  1. Scelgo l'id nuovo con prossimo_id(segnalazioni).
  2. Costruisco la Segnalazione con quell'id e i dati arrivati.
  3. La metto nel dizionario, alla chiave del suo id.
  4. La restituisco. Il 201 sta nel decoratore.
Python
@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 segnalazione

Passo 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}:

RigaCosa faCosa c'è dopo
prossimo_id(segnalazioni)Il più grande id è 4, più uno5
Segnalazione(id=5, …)Costruisce la scatola nuova, con i dati del corpoun oggetto con l'id 5
segnalazioni[segnalazione.id] = segnalazioneLa mette nel dizionario, alla chiave 5chiavi 1, 2, 4, 5
return segnalazioneFastAPI la trasforma in JSON, con il 201 del decoratore201 e la segnalazione

Le trappole.

Il codice sbagliatoCosa succedeIl test rosso
@app.post("/segnalazioni"), senza lo status_codeFunziona, ma risponde 200: «va tutto bene» e non «creato». I 201 dicono al client che qualcosa di nuovo esistetest_una_segnalazione_nuova
id=len(segnalazioni) + 1Le segnalazioni sono tre, 3 più 1 fa 4: ma il 4 c'è già, e viene sovrascritto. Una segnalazione sparisce, e nessuno se ne accorgetest_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] = datiNel dizionario finisce dati, il corpo senza id, al posto della segnalazione. La risposta della POST è giusta, ma l'archivio è rottotest_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.

  1. Prima il 404: se il tornello non c'è, la funzione si ferma (trova_tornello lo fa).
  2. Costruisco un Tornello nuovo: l'id dal percorso, tutto il resto dal corpo.
  3. Lo metto al posto del vecchio, alla stessa chiave.
  4. Lo restituisco.
Python
@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 tornello

Passo per passo. PUT /tornelli/2 con {"stazione_id": 1, "stato": "aperto", "passaggi": 310}:

RigaCosa faIl dizionario tornelli
trova_tornello(2)Il 2 c'è: niente errore, si va avantiinvariato
Tornello(id=2, …)Una scatola nuova, con aperto e 310invariato (la scatola nuova è ancora fuori)
tornelli[2] = tornelloLa chiave 2 punta alla scatola nuova; la vecchia (guasto, 300) non ha più etichettachiavi 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 sbagliatoCosa succedeIl test rosso
Niente trova_tornelloCon l'id 9 la PUT crea il tornello 9 (tornelli[9] = … aggiunge una chiave nuova) e risponde 200. Un tornello che nessuno ha montatotest_tornello_che_non_esiste
Il controllo (if tornello_id not in tornelli: raise …) dopo tornelli[tornello_id] = tornelloQuando arriva il controllo, il 9 ormai c'è: il 404 non parte più. Il lavoro è già stato fatto. Prima il 404, poi il lavorotest_tornello_che_non_esiste
vecchio = trova_tornello(…), poi vecchio.stato = dati.stato e return vecchioCambia 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.

  1. Se l'id non è tra le chiavi del dizionario, 404.
  2. Altrimenti tolgo la chiave (e la sua scatola) con del.
  3. Niente return: il 204 non ha corpo.
Python
@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 sbagliatoCosa succedeIl test rosso
Il decoratore senza status_code=status.HTTP_204_NO_CONTENTL'annuncio viene tolto, ma la risposta è 200 (con null come corpo) invece di 204test_togli_un_annuncio
Solo del annunci[annuncio_id], senza il controlloCon un id che non c'è, del dà KeyError: nel server vero un 500, invece del 404test_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 toltotest_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.

  1. codice_gia_usato guarda tutti i badge. Se ne trova uno diverso da tranne_id con quel codice, risponde True. Se finisce il giro senza trovarlo, False.
  2. Nella POST: se il codice è già usato, 409. Poi il lavoro di sempre.
  3. Nella PUT: stesso controllo, ma con tranne_id=badge_id, per non rifiutare il badge che tiene il suo codice.
Python
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
Python
@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 nuovo

Passo per passo. PUT /badge/4 con il codice B-04 (il suo). Dentro codice_gia_usato("B-04", tranne_id=4):

Giroaltroaltro.codice == "B-04"?altro.id != 4?Tutte e due?
1badge 1 (B-01)nosìno
2badge 2 (B-02)nosìno
3badge 3 (B-03)nosìno
4badge 4 (B-04)sìnono

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 sbagliatoCosa succedeIl 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 confrontatitest_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 badgein 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_idIl badge 4 che tiene il suo codice si trova in conflitto con sé stesso: la PUT risponde 409test_tranne_se_stesso, test_put_che_tiene_il_suo_codice
Il controllo con il 409 solo nella POST, non nella PUTUn badge nuovo non può avere un codice doppio, ma un badge che esiste sì: basta riscriverlo con una PUTtest_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.

Python
@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.

inizio GET /biciclette trovate = [] per ogni bicicletta in biciclette.values() passo passa_stazione: filtro assente o uguale passo passa_libera: filtro assente o uguale se passa_stazione and passa_libera sì: trovate.append(bicicletta) restituisci trovateGET /biciclettetrovate = []per ogni bicicletta inbiciclette.values()passa_stazione: filtroassente o ugualepassa_libera: filtro assenteo ugualepassa_stazione andpassa_liberatrovate.append(bicicletta)restituisci trovatenosìfiniti
La lista delle biciclette

Passo per passo. GET /biciclette?stazione_id=4&libera=true. I due filtri valgono 4 e True:

Biciclettapassa_stazionepassa_liberaPassa?
1 (stazione 4, libera)sìsìsì
2 (stazione 4, in uso)sìnono
3 (stazione 1, libera)nosì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 sbagliatoCosa succedeIl 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 presentitest_lista_di_una_stazione, test_lista_solo_le_libere, test_lista_solo_quelle_in_uso
passa_libera = not libera or bicicletta.libera == liberanot libera è vero anche per False: libera=false viene scambiato per «nessun filtro», e tornano tutte le biciclettetest_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 percorsotest_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.

Python
@app.get("/stazioni")
def lista_stazioni() -> list[Stazione]:
    aperte = []
    for stazione in stazioni.values():
        if stazione.aperta:
            aperte.append(stazione)
    return aperte

Livello 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.

Python
@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 stazione

Livello 3 · I treni, con un filtro

In italiano. Senza tipo, tutti i treni. Con tipo, il setaccio.

Python
@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 trovati

Livello 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ì.

Python
@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 fermi

Livello 5 · L'M30 entra in rete

In italiano. L'id con prossimo_id, il treno con quell'id, nel dizionario, restituito. 201 nel decoratore.

Python
@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 treno

Livello 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.

Python
@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 treno

Livello 7 · Via il treno di servizio

In italiano. Prima il 404, poi del. Niente return: il 204 non ha corpo.

Python
@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:

LivelloLa domandaCosa risponde la rete
1Quante stazioni sono aperte?5 (Porta Codice, Via Variabile, Largo Lista, Ponte Ciclo, Piazza Query)
2L'id di Vecchia Fiera6
3Quanti tram ci sono?4 (T05, T09, T28, T31)
4Quanti 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_id a 7, e tutto il resto com'era, guasto compreso;
  • 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 sbagliatoCosa succedeIl test rosso
Livello 1: return list(stazioni.values()), senza ifLe stazioni chiuse (Vecchia Fiera, il Deposito) compaiono nella lista: la prima cifra è sbagliatatest_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 chiusetest_livello_2_anche_una_stazione_chiusa, test_livello_4_una_stazione_senza_treni
Livello 3: il for senza il ramo if tipo is NoneSenza ?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) + 1In 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] = trenoLa risposta è giusta, ma il treno non è nel dizionario: la sala controllo non lo vede maitest_livello_5_il_treno_resta_in_rete
Livello 6: niente trova_trenoUna PUT su un id che non c'è crea un treno dal nulla, con 200 invece del 404test_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 404test_livello_7_la_seconda_volta_404, test_livello_7_treno_che_non_esiste