Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test3. Scrivere un testp. 73

Scrivere un test

Una domanda con la risposta già scritta

  • 10 minuti di lettura

Nadia Russo è la guardia della Linea Menta, badge B-03. Davanti a una funzione nuova dice sempre la stessa frase: «Di una funzione senza test non mi fido».

Non è diffidenza. È un metodo: se vuoi sapere che una funzione fa quello che dice, non la rileggi cento volte. Le fai una domanda, di cui conosci già la risposta, e guardi se risponde giusto. Un test è questo: una domanda con la risposta già scritta.

Nei capitoli prima hai già visto test scritti da altri: nel capitolo 2 il golden master ti diceva se avevi cambiato quello che il programma stampa. Qui i test li scrivi tu.

L'assert, e le tre fasi

Un test in pytest è una funzione il cui nome comincia con test_. Dentro c'è un assert: «afferma che questo è vero». Se è vero il test è verde, se è falso è rosso.

Python
from varchi import varchi_aperti


def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
    assert varchi_aperti(6, 1) == 5

Sei tornelli, uno guasto: ne restano cinque aperti. Ogni test ha tre fasi, anche quando una è una riga sola.

PREPARA                ESEGUI                   VERIFICA

totale = 6             varchi_aperti(6, 1)      assert … == 5
guasti = 1             ───────────────▶  ?      vero  → verde
(i dati di partenza)   (chiami la funzione)     falso → rosso

Il test tratta la funzione come una scatola nera: non guarda come è scritta dentro, guarda solo cosa entra (gli argomenti) e cosa esce (il return). Se domani la riscrivi, il test resta uguale. Come funzionano argomenti e return lo trovi in Le funzioni.

Un test serve solo se può diventare rosso

Un test verde non dimostra niente, da solo. Dimostra qualcosa solo se sarebbe diventato rosso con il codice sbagliato. Prova a immaginare un test così:

Python
def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
    varchi_aperti(6, 1) == 5

Manca l'assert. Python calcola il confronto, lo butta via, e il test finisce senza errori: verde. Sempre. Anche se la funzione restituisce 4, o 400.

Per questo gli esercizi della palestra non si fidano di te, e fanno una cosa semplice: prendono il codice giusto, ci mettono dentro una versione sbagliata apposta (un >= diventato >, un controllo tolto), e lanciano i tuoi test. Se restano tutti verdi, il controllo ti dice: «I tuoi test restano verdi anche se…». Manca un test che se ne accorga.

codice giusto            ──▶  i tuoi test  ──▶  verdi   (devono esserlo)
versione sbagliata 1     ──▶  i tuoi test  ──▶  almeno un rosso
versione sbagliata 2     ──▶  i tuoi test  ──▶  almeno un rosso

È anche il modo giusto di pensare mentre scrivi: dopo ogni test chiediti «che sbaglio potrebbe fare chi scrive questo codice, e il mio test lo vedrebbe?». Gli sbagli più probabili sono quasi sempre gli stessi: il confine (>= invece di >), il caso dimenticato, l'errore che non arriva.

Un test per comportamento, e il nome che lo racconta

Una funzione con tre comportamenti ha bisogno di tre test, non di uno con tre assert. Il motivo è pratico: nel test con tre assert il primo che fallisce ferma tutto, e degli altri due non sai niente.

Il nome fa il resto. Quando un test diventa rosso, pytest ti mostra prima di tutto il nome: se è una frase, sai cosa si è rotto senza aprire il file.

Python
def test_classe_bagaglio():                                 # cosa si è rotto? Boh
    ...

def test_dieci_chili_sono_ancora_un_bagaglio_leggero():     # lo dice il nome
    ...

Un buon nome si legge come una frase: «da dieci persone c'è lo sconto», «una comitiva senza persone è un errore». Niente test_1, niente test_funzione. È la regola dei nomi del capitolo 1, applicata ai test.

I numeri con la virgola: pytest.approx

I numeri con la virgola, nel computer, sono approssimati. Il caso più famoso:

Python
print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

Un test che scrive assert somma == 0.3 diventa rosso anche se il codice è giusto. La soluzione è dire a pytest «uguale, a meno di un'inezia»:

Python
import pytest

assert totale_scontrino([0.10, 0.20]) == pytest.approx(0.30)

approx accetta di default una differenza minuscola (un milionesimo, in proporzione). Se ti serve una tolleranza tua, pytest.approx(0.30, abs=0.01) dice «a meno di un centesimo». Ma non esagerare: con una tolleranza troppo larga il test non si accorge più degli errori piccoli, ed è proprio quello il suo mestiere.

L'errore deve arrivare: pytest.raises

Una funzione può dire «questo non lo faccio» sollevando un errore con raise (try, except, raise). Anche questo è un comportamento, e va provato: il test deve controllare che l'errore arrivi.

Python
import pytest

def test_un_orario_impossibile_e_un_errore():
    with pytest.raises(ValueError, match="25:10"):
        ora_in_minuti("25:10")

Il blocco with pytest.raises(ValueError): è verde se dentro succede un ValueError, rosso se non succede niente. Con match= controlli anche che il messaggio contenga quel pezzo di testo.

Tre cose che si assomigliano e si confondono:

ScriviDoveCosa fa
raise ValueError("…")nel codicesegnala l'errore a chi ha chiamato la funzione
assert condizionenel testverde se la condizione è vera, rosso se è falsa
with pytest.raises(ValueError):nel testverde se l'errore arriva, rosso se non arriva

Tanti casi, un test: parametrize

Provare i confini di una fascia oraria vuol dire sei test quasi identici. Si scrive il test una volta, e si elencano i valori:

Python
import pytest


@pytest.mark.parametrize(
    ("ora", "fascia"),
    [
        (0, "notte"),
        (5, "notte"),
        (6, "giorno"),
        (7, "punta"),
        (9, "punta"),
        (10, "giorno"),
    ],
)
def test_la_fascia_cambia_ai_confini(ora, fascia):
    assert fascia_oraria(ora) == fascia

I nomi tra parentesi ("ora", "fascia") diventano i parametri della funzione di test: pytest la lancia una volta per ogni riga della lista. Se una sola riga fallisce, pytest ti dice quale.

I confini sono i valori dove il comportamento cambia: se la fascia «punta» va dalle 7 alle 9, i valori da provare sono 6 e 7 (dove comincia), 9 e 10 (dove finisce). Quasi tutti i bug di questo tipo stanno lì: un < al posto di un <= sbaglia proprio un valore, e solo uno. Con le età di una tariffa (gratis fino a 13 anni, ridotta da 65) i confini sono 13, 14, 64, 65.

Le fixture di base

Non tutto si prova con un numero in ingresso e un numero in uscita. Pytest ti passa degli aiutanti, le fixture: li chiedi scrivendo il loro nome come parametro del test.

FixtureCosa ti dàQuando
tmp_pathuna cartella temporanea, vuota e solo tuala funzione legge o scrive un file: ci metti dentro un file di prova
capsysquello che la funzione ha stampatola funzione fa print invece di return
una tua, con @pytest.fixturequello che restituisce la funzione che scrivipiù test partono dagli stessi dati
Python
def test_l_avviso_dice_treno_e_minuti(capsys):
    stampa_avviso("M12", 5)
    uscita = capsys.readouterr()
    assert uscita.out == "Il treno M12 ha 5 minuti di ritardo\n"

capsys.readouterr() dà .out (stdout) e .err (stderr), come nel libro Python (Moduli e file). Il \n finale c'è perché print va a capo.

Python
@pytest.fixture
def ritardi():
    return {"M12": 5, "T28": 0}


def test_il_file_ha_una_riga_per_treno(tmp_path, ritardi):
    ...
ritardi = {"M12": 5, "T28": 0}ritardidict"M12"5"T28"0
I dati che la fixture passa a ogni test

La fixture ritardi si scrive una volta; ogni test che la chiede per nome (come parametro) riceve i dati preparati da capo. I file di prova si scrivono sempre in tmp_path, mai con un percorso scritto a mano: il percorso dei tuoi file non è quello del computer di chi lancia i test dopo di te.

Ricorda

  • Un test è una funzione test_… con un assert: prepara, esegui, verifica.
  • Un test senza assert è sempre verde: non prova niente.
  • Un test vale se diventa rosso quando il codice sbaglia: pensa agli sbagli probabili, soprattutto ai confini.
  • Un test per comportamento, e un nome che si legge come una frase.
  • Numeri con la virgola: pytest.approx. Errori: pytest.raises(TipoPreciso, match=…).
  • Tanti valori: parametrize. File: tmp_path. Cosa stampa: capsys. Dati comuni: @pytest.fixture.