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

I test con il database, esercizi spiegati

Cinque prove, un output vero per ognuna

  • 25 minuti di lettura

Cinque esempi, uno per ogni idea del capitolo. Ognuno ha lo stesso ritmo:

  1. Prevedi: leggi e scrivi su un foglio cosa succede. Prima di aprire la risposta.
  2. In italiano: cosa fa, a parole.
  3. Passo per passo: cosa succede e in che ordine.
  4. Cosa portiamo a casa: la cosa da ricordare.

Gli output sono veri: sono usciti da questi comandi, lanciati su una cartella come quella dello zip della palestra. Se vuoi rifarli, scarica lo zip e segui il suo README.md. In questa pagina la cartella si chiama ~/corso/db-test-con-il-database.


A · Due database, due destini

Preparo il mio database, controllo quante stazioni ci sono, lancio un test che ne aggiunge una, e riguardo.

Terminale
createdb db_test_con_il_database
psql -d db_test_con_il_database -f linea_menta.sql
psql -d db_test_con_il_database -c "SELECT count(*) FROM stazioni"
pytest palestra/test_stazioni.py::test_apri_una_stazione -v
psql -d db_test_con_il_database -c "SELECT count(*) FROM stazioni"
psql -d db_test_con_il_database_test -c "SELECT id, nome FROM stazioni ORDER BY id"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Dopo il test, quante stazioni ci sono nel database mio? E nel database dei test?

$ psql -d db_test_con_il_database -f linea_menta.sql
SET
DROP TABLE
CREATE TABLE
CREATE TABLE
CREATE TABLE
CREATE TABLE
INSERT 0 6
INSERT 0 9
INSERT 0 12
INSERT 0 9

$ psql -d db_test_con_il_database -c "SELECT count(*) FROM stazioni"
 count 
-------
     6
(1 riga)

$ pytest palestra/test_stazioni.py::test_apri_una_stazione -v
======================================= test session starts ========================================
platform darwin -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0 -- ~/corso/db-test-con-il-database/.venv/bin/python3
cachedir: .pytest_cache
rootdir: ~/corso/db-test-con-il-database
configfile: pytest.ini
plugins: anyio-4.16.0
collecting ... collected 1 item

palestra/test_stazioni.py::test_apri_una_stazione PASSED                                     [100%]

======================================== 1 passed in 0.31s =========================================

$ psql -d db_test_con_il_database -c "SELECT count(*) FROM stazioni"
 count 
-------
     6
(1 riga)

$ psql -d db_test_con_il_database_test -c "SELECT id, nome FROM stazioni ORDER BY id"
 id |     nome      
----+---------------
  1 | Porta Codice
  2 | Via Variabile
  3 | Largo Lista
  4 | Ponte Ciclo
  5 | Piazza Query
  6 | Vecchia Fiera
  7 | Corso Classe
(7 righe)

Nel mio: ancora 6. Nel database dei test: 7, con Corso Classe.

In italiano. Il test ha aggiunto Corso Classe, ma l'ha fatto nel database …_test. Il mio database non se n'è accorto.

Passo per passo.

CosaDove succede
createdb + psql -fCreo e riempio il mio database: 6 stazioni
pytest …conftest.py crea …_test (non l'ho creato io), lo riempie, poi il test aggiunge la stazione 7
count(*) sul mioSempre 6: nessun test l'ha toccato
SELECT sul _test7 righe: dopo l'ultimo test il database resta com'è, e ci vedo cosa ha lasciato

Cosa portiamo a casa. pytest scrive nel database …_test. Il tuo non cambia. E se un test ti sembra strano, psql -d …_test ti fa vedere cosa ha lasciato.


B · Il database torna come nuovo

Due test. Il primo aggiunge un treno, il secondo conta i treni.

Python
def test_aggiungo_un_treno(sql):
    sql("INSERT INTO treni (codice, vagoni, km, in_servizio) VALUES (%s, %s, %s, %s)", ("M30", 6, 0, True))
    assert len(sql("SELECT * FROM treni")) == 10


def test_conto_i_treni(sql):
    assert len(sql("SELECT * FROM treni")) == 9

I treni di partenza sono nove. Il primo test ne aggiunge uno e si aspetta dieci. Il secondo si aspetta nove.

Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Sembra una contraddizione: se il primo ne aggiunge uno, il secondo dovrebbe trovarne dieci. Ma i test partono ognuno da un database nuovo.

$ pytest palestra/test_prova_ricarica.py -v
======================================= test session starts ========================================
platform darwin -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0 -- ~/corso/db-test-con-il-database/.venv/bin/python3
cachedir: .pytest_cache
rootdir: ~/corso/db-test-con-il-database
configfile: pytest.ini
plugins: anyio-4.16.0
collecting ... collected 2 items

palestra/test_prova_ricarica.py::test_aggiungo_un_treno PASSED                               [ 50%]
palestra/test_prova_ricarica.py::test_conto_i_treni PASSED                                   [100%]

======================================== 2 passed in 0.04s =========================================

Tutti e due verdi. Il M30 del primo test è sparito prima che partisse il secondo.

Adesso la prova contraria. In conftest.py cambio una riga sola, quella della ricarica:

diff
-@pytest.fixture(autouse=True)
+@pytest.fixture(scope="session", autouse=True)
 def database_come_nuovo(database_dei_test):

Con scope="session" la ricarica gira una volta sola, all'inizio. Rilancio gli stessi due test:

$ pytest palestra/test_prova_ricarica.py -v
======================================= test session starts ========================================
platform darwin -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0 -- ~/corso/db-test-con-il-database/.venv/bin/python3
cachedir: .pytest_cache
rootdir: ~/corso/db-test-con-il-database
configfile: pytest.ini
plugins: anyio-4.16.0
collecting ... collected 2 items

palestra/test_prova_ricarica.py::test_aggiungo_un_treno PASSED                               [ 50%]
palestra/test_prova_ricarica.py::test_conto_i_treni FAILED                                   [100%]

============================================= FAILURES =============================================
________________________________________ test_conto_i_treni ________________________________________

sql = <function sql.<locals>.chiedi at 0x10aa360c0>

    def test_conto_i_treni(sql):
>       assert len(sql("SELECT * FROM treni")) == 9
E       AssertionError: assert 10 == 9
E        +  where 10 = len([{'id': 1, 'codice': 'M10', 'vagoni': 4, 'km': 1200, ...}, {'id': 2, 'codice': 'M12', 'vagoni': 4, 'km': 4800, ...}, {'id': 3, 'codice': 'M14', 'vagoni': 3, 'km': 5200, ...}, {'id': 4, 'codice': 'M16', 'vagoni': 6, 'km': 300, ...}, {'id': 5, 'codice': 'M18', 'vagoni': 4, 'km': 7100, ...}, {'id': 6, 'codice': 'M20', 'vagoni': 6, 'km': 0, ...}, ...])
E        +    where [{'id': 1, 'codice': 'M10', 'vagoni': 4, 'km': 1200, ...}, {'id': 2, 'codice': 'M12', 'vagoni': 4, 'km': 4800, ...}, {'id': 3, 'codice': 'M14', 'vagoni': 3, 'km': 5200, ...}, {'id': 4, 'codice': 'M16', 'vagoni': 6, 'km': 300, ...}, {'id': 5, 'codice': 'M18', 'vagoni': 4, 'km': 7100, ...}, {'id': 6, 'codice': 'M20', 'vagoni': 6, 'km': 0, ...}, ...] = <function sql.<locals>.chiedi at 0x10aa360c0>('SELECT * FROM treni')

palestra/test_prova_ricarica.py:7: AssertionError
===================================== short test summary info ======================================
FAILED palestra/test_prova_ricarica.py::test_conto_i_treni - AssertionError: assert 10 == 9
=================================== 1 failed, 1 passed in 0.07s =====================================

Il secondo test trova dieci treni: il M30 del primo è ancora lì. Un test dipende dall'altro, e se qualcuno cambia l'ordine, o ne lancia uno solo, tutto cambia.

(Rimetti la riga com'era, prima di andare avanti.)

In italiano. La ricarica prima di ogni test è quello che rende i test indipendenti: ognuno parte dagli stessi nove treni.

Passo per passo.

Con la ricarica prima di ogni testCon la ricarica una volta sola
Ricarico → primo test (M30) → ricarico → secondo test: 9 treniRicarico → primo test (M30) → secondo test: 10 treni

Cosa portiamo a casa. Il database nuovo a ogni test è una promessa: «partirai sempre da qui». Se un test conta su quello che ha fatto un altro, la promessa lo smaschera. La soluzione non è togliere la ricarica: è far preparare al test i suoi dati.


C · Il nome del database, prima degli import

Dov'è che database.py sceglie il database? Lo chiedo a Python in due modi: dal terminale, e dentro un test.

Python
import database


def test_il_nome_del_database():
    print("database.py usa:", database.NOME_DB)
Terminale
cd palestra && python -c "import database; print(database.NOME_DB)"
pytest palestra/test_prova_nome.py -s -q
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Dal terminale: il mio database. Dentro pytest: quello dei test. L'opzione -s fa vedere i print dei test.

$ cd palestra && python -c "import database; print(database.NOME_DB)"
db_test_con_il_database

$ pytest palestra/test_prova_nome.py -s -q
database.py usa: db_test_con_il_database_test
.
1 passed in 0.15s

In italiano. Lo stesso database.py, due nomi diversi. A scegliere è la variabile MENTA_DB: nel terminale non c'è, e vale il nome di partenza. In pytest l'ha scritta conftest.py.

Passo per passo.

  1. pytest parte e legge conftest.py.
  2. La riga os.environ["MENTA_DB"] = NOME_DB_TEST gira subito, appena il file viene letto.
  3. Poi pytest importa il tuo test, che importa database.
  4. database.py legge MENTA_DB, e trova già il nome del database …_test.

Se la riga fosse stata scritta dopo l'import, al punto 4 MENTA_DB non ci sarebbe: l'API userebbe il tuo database, e i test lo riempirebbero di prove.

Cosa portiamo a casa. L'ordine conta: la variabile prima, l'import dopo. È per questo che sta in cima a conftest.py.


D · 201 e niente salvato

Prendo l'API delle stazioni e al posto di db.commit() metto db.flush(). Poi scrivo due test per la stessa richiesta: uno guarda solo la risposta, l'altro anche il database.

Python
def test_risposta_soltanto():
    risposta = client.post("/stazioni", json=NUOVA)
    assert risposta.status_code == 201
    assert risposta.json()["id"] == 7


def test_risposta_e_database(sql):
    risposta = client.post("/stazioni", json=NUOVA)
    assert risposta.status_code == 201
    assert sql("SELECT * FROM stazioni WHERE id = %s", (7,)) != []
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il primo è verde: l'API dice 201 e dà l'id 7, proprio come se avesse salvato. Il secondo è rosso: nel database la riga 7 non c'è.

$ pytest palestra/test_prova_flush.py -v --show-capture=no
======================================= test session starts ========================================
platform darwin -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0 -- ~/corso/db-test-con-il-database/.venv/bin/python3
cachedir: .pytest_cache
rootdir: ~/corso/db-test-con-il-database
configfile: pytest.ini
plugins: anyio-4.16.0
collecting ... collected 2 items

palestra/test_prova_flush.py::test_risposta_soltanto PASSED                                  [ 50%]
palestra/test_prova_flush.py::test_risposta_e_database FAILED                                [100%]

============================================= FAILURES =============================================
_____________________________________ test_risposta_e_database _____________________________________

sql = <function sql.<locals>.chiedi at 0x1095acc20>

    def test_risposta_e_database(sql):
        risposta = client.post("/stazioni", json=NUOVA)
        assert risposta.status_code == 201
>       assert sql("SELECT * FROM stazioni WHERE id = %s", (7,)) != []
E       AssertionError: assert [] != []
E        +  where [] = <function sql.<locals>.chiedi at 0x1095acc20>('SELECT * FROM stazioni WHERE id = %s', (7,))

palestra/test_prova_flush.py:18: AssertionError
===================================== short test summary info ======================================
FAILED palestra/test_prova_flush.py::test_risposta_e_database - AssertionError: assert [] != []
=================================== 1 failed, 1 passed in 0.33s =====================================

(--show-capture=no dice a pytest di non ripetere sotto l'errore il SQL che SQLAlchemy stampa da solo: qui disturberebbe.)

In italiano. Con flush la modifica arriva al database ma non viene consegnata: la sessione si chiude e la annulla. L'API risponde 201, l'id c'è, e nel database non c'è niente.

Passo per passo.

Mossa dell'APICosa vede chi rispondeCosa c'è nel database
db.add(stazione)niente di nuovoniente
db.flush()l'id 7 (il database l'ha assegnato)niente: non è consegnato
db.refresh(stazione)la stazione con l'idniente
la sessione si chiude201 con il corponiente: annullato

Cosa portiamo a casa. Il primo test è il peggiore dei test: verde e bugiardo. Per ogni scrittura, il test guarda la risposta e il database, con sql(...).


E · La fixture che prepara i dati

Servono due test che partano da una stazione che non è nei dati di base: Torre Dati. Invece di inserirla a mano in tutti e due, la prepara una fixture.

Python
import pytest


@pytest.fixture
def stazione_di_prova(sql):
    riga = sql(
        "INSERT INTO stazioni (nome, aperta, tornelli) VALUES (%s, %s, %s) RETURNING id",
        ("Torre Dati", True, 4),
    )
    return riga[0]["id"]


def test_la_stazione_di_prova_c_e(stazione_di_prova, sql):
    assert stazione_di_prova == 7
    assert sql("SELECT nome FROM stazioni WHERE id = %s", (stazione_di_prova,))[0]["nome"] == "Torre Dati"


def test_anche_qui_la_stazione_e_nuova(stazione_di_prova, sql):
    assert stazione_di_prova == 7
    assert len(sql("SELECT * FROM stazioni")) == 7
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Tutti e due i test ricevono la stazione numero 7 e ne vedono una sola in più: il database è nuovo per entrambi.

$ pytest palestra/test_prova_fixture.py -v
======================================= test session starts ========================================
platform darwin -- Python 3.12.13, pytest-9.2.0, pluggy-1.7.0 -- ~/corso/db-test-con-il-database/.venv/bin/python3
cachedir: .pytest_cache
rootdir: ~/corso/db-test-con-il-database
configfile: pytest.ini
plugins: anyio-4.16.0
collecting ... collected 2 items

palestra/test_prova_fixture.py::test_la_stazione_di_prova_c_e PASSED                         [ 50%]
palestra/test_prova_fixture.py::test_anche_qui_la_stazione_e_nuova PASSED                    [100%]

======================================== 2 passed in 0.05s =========================================

In italiano. Una fixture è una funzione che prepara qualcosa per un test. Il test la chiede scrivendone il nome tra i parametri, e pytest la esegue prima del test e gli passa quello che restituisce.

Il disegno.

inizio pytest lancia i test per ogni test passo ricarica il database passo costruisce sql passo stazione_di_prova inserisce la 7 passo il test controllapytest lancia i testper ogni testricarica il databasecostruisce sqlstazione_di_prova inseriscela 7il test controllafiniti
Il giro di ogni test

Passo per passo (per il primo test):

  1. pytest ricarica il database: sei stazioni, la 7 non c'è ancora.
  2. Il test chiede stazione_di_prova e sql. pytest costruisce prima sql, perché la fixture ne ha bisogno.
  3. La fixture inserisce Torre Dati con RETURNING id e restituisce 7.
  4. Il test riceve 7 nel parametro stazione_di_prova e controlla.
  5. Il secondo test ricomincia dal punto 1: ricarica, di nuovo un database a sei stazioni, di nuovo il 7.

Cosa portiamo a casa. Una fixture che inserisce con sql(...) e restituisce l'id (un numero, non la lista di righe: riga[0]["id"]) è il modo più pulito per preparare i dati di un test. Ogni test che la chiede ne riceve una nuova.