I test con il database, 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.
Qui le trappole non sono nel tuo codice ma nelle API sbagliate: ognuna è una versione di stazioni.py, segnalazioni.py o treni.py con un errore dentro. I test giusti devono diventare rossi. Se i tuoi test restano verdi su un'API rotta, quel pezzo dell'API non è collaudato.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · Il collaudo delle stazioni
In italiano. Primo test: chiamo l'API con la stazione nuova, controllo 201 e il corpo (con l'id 7, perché dopo la ricarica è sempre il 7), poi guardo nel database che la riga 7 abbia nome e tornelli giusti. Secondo test: chiamo con un nome che c'è già, controllo 409 e il detail, poi conto le stazioni nel database: sempre sei.
def test_apri_una_stazione(sql):
risposta = client.post("/stazioni", json={"nome": "Corso Classe", "aperta": True, "tornelli": 6})
assert risposta.status_code == 201
assert risposta.json() == {"id": 7, "nome": "Corso Classe", "aperta": True, "tornelli": 6}
riga = sql("SELECT * FROM stazioni WHERE id = %s", (7,))[0]
assert riga["nome"] == "Corso Classe"
assert riga["tornelli"] == 6
def test_nome_gia_usato(sql):
risposta = client.post("/stazioni", json={"nome": "Largo Lista", "aperta": True, "tornelli": 6})
assert risposta.status_code == 409
assert risposta.json()["detail"] == "Nome già usato da un'altra stazione"
assert len(sql("SELECT * FROM stazioni")) == 6Le trappole.
| L'API sbagliata | Cosa succede | Il test rosso |
|---|---|---|
db.flush() al posto di db.commit() | Risponde 201 con l'id 7, ma nel database non c'è niente. Il test legge la riga 7: IndexError: list index out of range, la lista è vuota | test_apri_una_stazione |
@app.post("/stazioni") senza status_code=201 | FastAPI risponde 200: assert 200 == 201 | test_apri_una_stazione |
Niente controllo sul nome (via il db.scalar e l'if) | Il database dice no da solo: UniqueViolation: duplicate key value violates unique constraint "stazioni_nome_key", e senza 409 il test salta con un errore | test_nome_gia_usato |
La prima è quella del capitolo: se il test guardasse solo la risposta, sarebbe verde.
2 · I test che si pestano i piedi
In italiano. Il secondo test ha bisogno di una segnalazione da chiudere: la inserisce lui con sql(...) e si fa dare l'id con RETURNING. Poi chiude proprio quella. Il terzo ha bisogno di una settima segnalazione aperta: ne inserisce una, e poi conta. Il primo test era già indipendente.
def test_risolvi_la_segnalazione_di_prima(sql):
nuova = sql(
"INSERT INTO segnalazioni (treno_id, autore_id, descrizione, gravita) VALUES (%s, %s, %s, %s) RETURNING id",
(2, 2, "Luce di cortesia che lampeggia", 1),
)[0]["id"]
risposta = client.put(f"/segnalazioni/{nuova}/risolvi")
assert risposta.status_code == 200
assert risposta.json()["risolta"] is True
assert sql("SELECT risolta FROM segnalazioni WHERE id = %s", (nuova,))[0]["risolta"] is True
def test_le_aperte_sono_sette(sql):
sql(
"INSERT INTO segnalazioni (treno_id, autore_id, descrizione, gravita) VALUES (%s, %s, %s, %s)",
(2, 2, "Luce di cortesia che lampeggia", 1),
)
risposta = client.get("/segnalazioni", params={"risolta": False})
assert risposta.status_code == 200
assert len(risposta.json()) == 7Passo per passo (il secondo test).
| Passo | Cosa succede |
|---|---|
| 1 | pytest ricarica il database: nove segnalazioni, la prossima è la 10 |
| 2 | Il test inserisce la sua segnalazione: RETURNING id restituisce [{"id": 10}], e [0]["id"] è 10 |
| 3 | PUT /segnalazioni/10/risolvi: l'API la trova, la segna risolta, fa il commit |
| 4 | Il test controlla la risposta e poi, con sql, la riga nel database |
test_isolamento.py lancia ognuno dei tre test da solo, in un pytest tutto suo: con questa soluzione tutti reggono.
Le trappole.
| L'API sbagliata | Cosa succede | Il test rosso |
|---|---|---|
PUT senza db.commit() (e senza refresh) | La risposta dice risolta: true, ma nel database è ancora false: assert False is True | test_risolvi_la_segnalazione_di_prima |
Il filtro ?risolta= ignorato | Torna l'elenco intero: assert 10 == 7 | test_le_aperte_sono_sette |
POST senza db.commit() ma con db.refresh | InvalidRequestError: Instance '<SegnalazioneDB …>' is not persistent within this Session | test_apri_una_segnalazione |
3 · Il treno di prova
In italiano. La fixture inserisce il M30 con RETURNING id e restituisce il numero. Ogni test la chiede tra i parametri e lavora su quel treno: il primo lo manda in officina e guarda risposta e riga; il secondo lo toglie e controlla che la riga non ci sia più; il terzo inserisce una segnalazione su quel treno, prova a toglierlo e controlla 409 e che il treno ci sia ancora.
@pytest.fixture
def treno_nuovo(sql):
riga = sql(
"INSERT INTO treni (codice, vagoni, km, in_servizio, stazione_id) VALUES (%s, %s, %s, %s, %s) RETURNING id",
("M30", 6, 0, True, 1),
)
return riga[0]["id"]
def test_manda_in_officina_un_treno(treno_nuovo, sql):
risposta = client.put(f"/treni/{treno_nuovo}/officina")
assert risposta.status_code == 200
assert risposta.json()["in_servizio"] is False
assert risposta.json()["stazione_id"] is None
treno = sql("SELECT * FROM treni WHERE id = %s", (treno_nuovo,))[0]
assert treno["in_servizio"] is False
assert treno["stazione_id"] is None
def test_togli_un_treno_senza_segnalazioni(treno_nuovo, sql):
risposta = client.delete(f"/treni/{treno_nuovo}")
assert risposta.status_code == 204
assert sql("SELECT * FROM treni WHERE id = %s", (treno_nuovo,)) == []
def test_non_togli_un_treno_con_segnalazioni(treno_nuovo, sql):
sql(
"INSERT INTO segnalazioni (treno_id, autore_id, descrizione, gravita) VALUES (%s, %s, %s, %s)",
(treno_nuovo, 2, "Porta che non si chiude", 2),
)
risposta = client.delete(f"/treni/{treno_nuovo}")
assert risposta.status_code == 409
assert risposta.json()["detail"] == "Il treno ha delle segnalazioni"
assert len(sql("SELECT * FROM treni WHERE id = %s", (treno_nuovo,))) == 1Passo per passo (il terzo test).
| Passo | Cosa succede |
|---|---|
| 1 | Ricarica: nove treni |
| 2 | pytest costruisce sql, poi treno_nuovo: M30 con id 10 |
| 3 | Il test inserisce una segnalazione con treno_id 10 |
| 4 | DELETE /treni/10: l'API trova una segnalazione di quel treno e risponde 409 |
| 5 | Il test controlla il 409, il detail e che la riga 10 sia ancora lì |
Le trappole.
| L'API sbagliata | Cosa succede | Il test rosso |
|---|---|---|
Officina senza db.commit() | Il refresh rilegge la riga vecchia: la risposta dice ancora in servizio, assert True is False | test_manda_in_officina_un_treno |
DELETE senza db.commit() | Risponde 204, ma il treno c'è ancora: la lista non è vuota | test_togli_un_treno_senza_segnalazioni |
DELETE senza il controllo delle segnalazioni | Il database dice no: ForeignKeyViolation: … Key (id)=(10) is still referenced from table "segnalazioni" | test_non_togli_un_treno_con_segnalazioni |
Una trappola per tutto il capitolo
C'è un'ultima trappola, e sta in conftest.py: la ricarica con scope="session", cioè una volta sola. I test dello zip diventano rossi uno dopo l'altro, perché ognuno trova i dati lasciati da quelli di prima.
Il conftest.py sbagliato | Cosa succede | I test rossi |
|---|---|---|
@pytest.fixture(scope="session", autouse=True) sulla ricarica | I dati dei test si accumulano. Gli id non sono più quelli attesi, i conteggi sono sbagliati. Il M30 della fixture viene inserito due volte: UniqueViolation | test_apri_una_segnalazione, test_le_aperte_sono_sette, test_nome_gia_usato (più due errori nei test dei treni) |
Per questo i test indipendenti non sono una questione di buone maniere: sono quello che permette di scriverli in qualsiasi ordine e di lanciarne uno solo.