Vai al contenuto
code-to-code

Apro l'indice…

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

Il database nell'API6. I test con il databasep. 141

I test con il database

Un database solo per le prove, sempre come nuovo

  • 10 minuti di lettura

Ernesto Pozzi, il capo deposito, non mette un'API sulla linea senza la prova del nove. «Va bene che funziona», dice. «Ma funziona dopo che l'hai provata, o finché non la provi?»

Il problema è questo. Un test di DELETE cancella una riga vera. Un test di POST ne aggiunge una. Se i test lavorano sul tuo database, ogni giro di pytest ti cambia i dati sotto le mani: il treno che cercavi non c'è più, la stazione nuova compare da sola, e domani il test che ieri era verde è rosso.

Questo capitolo spiega come si fa in modo che i test possano scrivere quello che vogliono senza toccare niente di tuo.

Due database, due destini

Ogni zip di questo libro ha due database:

DatabaseDi chi èChi lo creaCosa gli succede
db_test_con_il_databaseTuoTu, con createdbQuello che salvi resta
db_test_con_il_database_testDei testpytest, da solo, la prima voltaTorna come nuovo prima di ogni test

Il nome del secondo è sempre il primo più _test. Il disegno:

 il tuo terminale                          il terminale di pytest
 fastapi dev palestra/stazioni.py          pytest palestra/test_stazioni.py
        │                                          │
        │  la variabile MENTA_DB non c'è:          │  conftest.py scrive MENTA_DB
        │  database.py usa il nome di partenza     │  PRIMA di importare il tuo codice
        ▼                                          ▼
 ┌──────────────────────────┐             ┌──────────────────────────────┐
 │ db_test_con_il_database  │             │ db_test_con_il_database_test │
 │ i tuoi dati: restano     │             │ di pytest: ogni test lo      │
 └──────────────────────────┘             │ trova come nuovo             │
                                          └──────────────────────────────┘

Il codice dell'API è lo stesso nei due casi. Cambia una sola cosa: il nome del database, che database.py legge dalla variabile d'ambiente MENTA_DB. Chi la imposta è conftest.py.

Il file conftest.py

conftest.py è un file con un nome speciale: pytest lo legge da solo, prima di tutti i test della cartella, senza che nessun test lo importi. Dentro ci vanno le fixture che servono a molti test (le fixture di base le hai viste in Scrivere un test).

Quello del tuo zip fa quattro cose. Le leggi una alla volta.

1 · Dice quale database usare, prima di tutto.

Python
NOME_DB_TEST = "db_test_con_il_database_test"
os.environ["MENTA_DB"] = NOME_DB_TEST

database.py legge MENTA_DB una volta sola, nel momento in cui viene importato. Se conftest.py scrivesse la variabile dopo l'import, sarebbe tardi: l'API avrebbe già il nome del tuo database. Per questo la riga sta in cima al file, fuori da ogni funzione: gira appena pytest legge conftest.py, prima che un test importi stazioni.

2 · Crea il database dei test, se non c'è.

Python
@pytest.fixture(scope="session", autouse=True)
def database_dei_test():
    ...

Due parole nuove nella riga del decoratore:

  • scope="session": la fixture gira una volta sola per tutto il giro di pytest, non una per test. Basta una volta per creare un database.
  • autouse=True: la fixture parte da sola, senza che un test la chieda tra i suoi parametri.

3 · Lo riporta come nuovo, prima di ogni test.

Python
@pytest.fixture(autouse=True)
def database_come_nuovo(database_dei_test):
    with psycopg.connect(dbname=NOME_DB_TEST) as conn:
        for file in FILE_SQL:
            conn.execute(file.read_text(encoding="utf-8"))

Senza scope, la fixture gira una volta per ogni test. Rilegge linea_menta.sql e lo manda al database. Il file comincia con DROP TABLE IF EXISTS (butta le quattro tabelle) e poi rifà tutto: CREATE TABLE e INSERT. È lo stesso comando che dai tu con psql -f (lo trovi in Scrivere), solo che lo dà pytest a ogni test.

Il with fa il COMMIT quando finisce: il database è pronto prima che il test parta.

4 · Presta ai test la funzione sql(...).

Python
@pytest.fixture
def sql():
    def chiedi(query, valori=None):
        ...
    return chiedi

Un test che la mette tra i parametri, def test_x(sql):, riceve una funzione. sql("SELECT * FROM stazioni") dà la lista delle righe come dizionari. Con un valore: sql("SELECT * FROM treni WHERE codice = %s", ("M12",)): il buco %s e la tupla, come in psycopg.

Perché serve? Perché per sapere se l'API ha salvato davvero, non puoi chiederlo all'API: devi guardare nel database con un altro canale. sql è quel canale.

Perché «prima» e non «dopo»

La ricarica gira prima di ogni test, non dopo. Due ragioni:

  • Se un test si rompe a metà, o fermi pytest con Ctrl+C, un «dopo» non girerebbe. Un «prima» sì: il test successivo parte sempre pulito.
  • Dopo l'ultimo test il database resta com'è: puoi guardarci dentro con psql per capire cosa ha fatto il test. Lo vedrai negli esercizi spiegati.

Test indipendenti

Dato che il database torna come nuovo prima di ogni test, un test non può contare su quello che ha fatto il test prima. Tre regole:

  1. Ogni test si prepara i suoi dati. Serve una segnalazione da chiudere? La inserisce lui, con sql(...), dentro il test (o in una fixture che il test chiede).
  2. Nessun test dipende dall'ordine. Ognuno deve passare anche da solo (pytest file::test) e anche se li lanci al contrario.
  3. Gli id partono sempre uguali. Dopo la ricarica, la prossima stazione è la 7, il prossimo treno il 10, la prossima segnalazione la 10. Puoi scriverlo nel test: non cambia mai.

Un test che passa solo perché quello di prima ha lasciato un treno nel database è un test fragile: verde oggi, rosso domani, e non sai perché. Con la ricarica, diventa rosso subito: è una fortuna.

Un test di scrittura guarda nel database

Scrivere in un database ha due passi: preparare la modifica e consegnarla con il commit (il carrello della sessione: add mette dentro, commit consegna). Ora immagina che nell'API manchi il commit.

Python
    db.add(stazione)
    db.flush()          # al posto di db.commit()

flush manda la modifica al database ma non la consegna: alla fine della richiesta, la sessione si chiude e la modifica sparisce. La risposta dell'API però è bella: 201, la stazione con il suo id. Un test che guarda solo la risposta è verde.

La regola: un test di una scrittura controlla due cose, la risposta e il database.

Python
risposta = client.post("/stazioni", json=nuova)
assert risposta.status_code == 201                       # la risposta
assert sql("SELECT * FROM stazioni WHERE id = %s", (7,)) != []   # il database

Lo provi dal vivo negli esercizi spiegati.

TestClient contro il database dei test

Il TestClient lo conosci dal libro HTTP e API: chiama l'API come farebbe un client vero, ma senza accendere il server.

Python
from fastapi.testclient import TestClient

from stazioni import app

client = TestClient(app)

Dentro l'API, get_db apre la sessione sul database che dice database.py: nei test, quello _test. Così client.post(...) scrive nel database dei test, e sql(...) lo legge dallo stesso posto. Due strade, un solo database: se un lato dice una cosa e l'altro un'altra, il test è rosso.

Ricorda

  • I test hanno un database tutto loro, …_test: i tuoi dati non si toccano mai.
  • conftest.py imposta MENTA_DB prima degli import, crea il database, lo ricarica prima di ogni test e presta sql(...).
  • scope="session" = una volta sola. autouse=True = parte da sola.
  • Ogni test si prepara i suoi dati e non conta su nessun altro test.
  • Un test di scrittura guarda la risposta e il database: flush al posto di commit risponde 201 e non salva niente.