Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test3. Scrivere un testp. 78

Scrivere un test, esercizi spiegati

Sei funzioni giuste, e i test di Nadia

  • 25 minuti di lettura

Sei esempi. In ognuno Nadia Russo ha davanti una funzione e scrive i suoi test. Ogni esempio ha lo stesso ritmo:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa dice pytest. Prima di aprire la risposta.
  2. In italiano: cosa prova il test, a parole.
  3. Passo per passo: cosa succede, una riga alla volta.
  4. Cosa portiamo a casa: la cosa da ricordare.

Tutti gli output sono usciti davvero da pytest. Ho tolto solo le righe con i percorsi del computer. Per provarli: una cartella nuova, il venv acceso, un file per il codice e uno per il test (il nome del test comincia con test_), poi pytest. Come si lancia e come si legge l'output: Lanciare i test.


A · Quanti tornelli funzionano?

La funzione di Porta Codice conta i tornelli aperti: tutti, meno quelli guasti. Nadia scrive il suo primo test. Ma qualcuno, nella notte, ha toccato la funzione.

Python
# varchi.py
def varchi_aperti(totale: int, guasti: int) -> int:
    """I tornelli che funzionano: tutti meno quelli guasti."""
    return totale - guasti - 1
Python
# test_varchi.py
from varchi import varchi_aperti


def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
    assert varchi_aperti(6, 1) == 5
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il test è rosso. Sei tornelli e uno guasto fanno cinque, ma la funzione ha un - 1 di troppo e dà quattro.

============================= test session starts ==============================
collected 1 item

test_varchi.py F                                                         [100%]

=================================== FAILURES ===================================
_______________ test_i_varchi_aperti_sono_i_totali_meno_i_guasti _______________

    def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
>       assert varchi_aperti(6, 1) == 5
E       assert 4 == 5
E        +  where 4 = varchi_aperti(6, 1)

test_varchi.py:5: AssertionError
=========================== short test summary info ============================
FAILED test_varchi.py::test_i_varchi_aperti_sono_i_totali_meno_i_guasti - ass...
============================== 1 failed in 0.01s ===============================

Si legge dal basso: FAILED dice quale test, la riga con > dice quale assert, le righe E dicono cosa è uscito (4) e cosa ci si aspettava (5).

In italiano. Il test chiama la funzione con 6 tornelli e 1 guasto, e afferma che il risultato è 5.

Passo per passo.

FaseRigaCosa succede
Prepara6 e 1i dati di partenza, scritti direttamente nella chiamata
Eseguivarchi_aperti(6, 1)la funzione risponde 4
Verificaassert … == 54 == 5 è falso: il test diventa rosso

Togliamo il - 1 dalla funzione e rilanciamo: 1 passed. Il test c'è per questo: è rosso quando il codice sbaglia, verde quando è giusto.

Adesso la stessa funzione, sempre con il - 1 di troppo, ma con un test dove Nadia ha dimenticato una parola:

Python
def test_i_varchi_aperti_sono_i_totali_meno_i_guasti():
    varchi_aperti(6, 1) == 5
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
============================= test session starts ==============================
collected 1 item

test_varchi.py .                                                         [100%]

============================== 1 passed in 0.00s ===============================

Verde, con il codice sbagliato. Senza assert Python calcola 4 == 5, trova False, e lo butta via. Nessuno gli ha chiesto di arrabbiarsi.

Cosa portiamo a casa. Un test senza assert è sempre verde. Un test verde ti dice qualcosa solo se lo hai visto, almeno una volta, diventare rosso con il codice sbagliato.


B · Il bagaglio: un test per comportamento

Alla biglietteria di Largo Lista i bagagli hanno tre classi: leggero fino a 10 kg compresi, medio fino a 23 compresi, pesante oltre. Il codice ha un errore sul confine dei 10 kg: ha scritto kg < 10 invece di kg <= 10.

Python
# bagagli.py
def classe_bagaglio(kg: float) -> str:
    """leggero fino a 10 kg compresi, medio fino a 23 compresi, poi pesante."""
    if kg < 10:
        return "leggero"
    if kg <= 23:
        return "medio"
    return "pesante"

Prima versione del test, un test solo:

Python
def test_classe_bagaglio():
    assert classe_bagaglio(4) == "leggero"
    assert classe_bagaglio(10) == "leggero"
    assert classe_bagaglio(23) == "medio"
    assert classe_bagaglio(30) == "pesante"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
============================= test session starts ==============================
collected 1 item

test_bagagli.py F                                                        [100%]

=================================== FAILURES ===================================
_____________________________ test_classe_bagaglio _____________________________

    def test_classe_bagaglio():
        assert classe_bagaglio(4) == "leggero"
>       assert classe_bagaglio(10) == "leggero"
E       AssertionError: assert 'medio' == 'leggero'
E         
E         - leggero
E         + medio

test_bagagli.py:6: AssertionError
=========================== short test summary info ============================
FAILED test_bagagli.py::test_classe_bagaglio - AssertionError: assert 'medio'...
============================== 1 failed in 0.01s ===============================

Il test trova l'errore, ma il nome non dice niente, e il secondo assert ha fermato tutto: le righe con 23 e 30 non sono mai state eseguite. Non sai se vanno bene.

In italiano. Un test per ogni comportamento, con un nome che lo racconta.

Python
def test_un_bagaglio_di_pochi_chili_e_leggero():
    assert classe_bagaglio(4) == "leggero"


def test_dieci_chili_sono_ancora_un_bagaglio_leggero():
    assert classe_bagaglio(10) == "leggero"


def test_ventitre_chili_sono_ancora_un_bagaglio_medio():
    assert classe_bagaglio(23) == "medio"


def test_oltre_ventitre_chili_e_pesante():
    assert classe_bagaglio(30) == "pesante"

Con pytest -v:

============================= test session starts ==============================
collecting ... collected 4 items

test_bagagli.py::test_un_bagaglio_di_pochi_chili_e_leggero PASSED        [ 25%]
test_bagagli.py::test_dieci_chili_sono_ancora_un_bagaglio_leggero FAILED [ 50%]
test_bagagli.py::test_ventitre_chili_sono_ancora_un_bagaglio_medio PASSED [ 75%]
test_bagagli.py::test_oltre_ventitre_chili_e_pesante PASSED              [100%]

=================================== FAILURES ===================================
_______________ test_dieci_chili_sono_ancora_un_bagaglio_leggero _______________

    def test_dieci_chili_sono_ancora_un_bagaglio_leggero():
>       assert classe_bagaglio(10) == "leggero"
E       AssertionError: assert 'medio' == 'leggero'
E         
E         - leggero
E         + medio

test_bagagli.py:9: AssertionError
=========================== short test summary info ============================
FAILED test_bagagli.py::test_dieci_chili_sono_ancora_un_bagaglio_leggero - As...
========================= 1 failed, 3 passed in 0.01s ==========================

Passo per passo.

TestCosa provaEsito
test_un_bagaglio_di_pochi_chili_e_leggeroil caso facileverde
test_dieci_chili_sono_ancora_un_bagaglio_leggeroil confine tra leggero e mediorosso
test_ventitre_chili_sono_ancora_un_bagaglio_medioil confine tra medio e pesanteverde
test_oltre_ventitre_chili_e_pesanteun caso pesanteverde

Il nome del test rosso dice già tutto: dieci chili dovrebbero essere ancora leggeri. Non serve aprire il file per capire cosa si è rotto.

Cosa portiamo a casa. Un comportamento, un test; il nome si legge come una frase. Il caso facile (4 kg) lo passa anche il codice sbagliato: sono i confini che lo smascherano.


C · Il totale dello scontrino

Il distributore di Via Variabile somma i prezzi di uno scontrino. Nadia prova due caffè da 10 e 20 centesimi.

Python
# scontrino.py
def totale_scontrino(prezzi: list[float]) -> float:
    """La somma dei prezzi, senza arrotondare."""
    return sum(prezzi)
Python
# test_scontrino.py
from scontrino import totale_scontrino


def test_il_totale_somma_i_prezzi():
    assert totale_scontrino([0.10, 0.20]) == 0.30
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Rosso, anche se la funzione è giusta.

============================= test session starts ==============================
collected 1 item

test_scontrino.py F                                                      [100%]

=================================== FAILURES ===================================
________________________ test_il_totale_somma_i_prezzi _________________________

    def test_il_totale_somma_i_prezzi():
>       assert totale_scontrino([0.10, 0.20]) == 0.30
E       assert 0.30000000000000004 == 0.3
E        +  where 0.30000000000000004 = totale_scontrino([0.1, 0.2])

test_scontrino.py:5: AssertionError
=========================== short test summary info ============================
FAILED test_scontrino.py::test_il_totale_somma_i_prezzi - assert 0.3000000000...
============================== 1 failed in 0.01s ===============================

0.1 + 0.2 nel computer non fa esattamente 0.3: fa 0.30000000000000004. Non è un bug della funzione: è come si scrivono i numeri con la virgola.

In italiano. Il test deve dire «uguale a 0,30, a meno di un'inezia». Si scrive con pytest.approx.

Python
import pytest
from scontrino import totale_scontrino


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

Con pytest -v:

============================= test session starts ==============================
collecting ... collected 1 item

test_scontrino.py::test_il_totale_somma_i_prezzi PASSED                  [100%]

============================== 1 passed in 0.00s ===============================

Ora la prova che approx non è un colabrodo. Nella funzione mettiamo uno sbaglio vero (+ 0.5):

E       assert 0.8 == 0.3 ± 3.0e-07
E         
E         comparison failed
E         Obtained: 0.8
E         Expected: 0.3 ± 3.0e-07

± 3.0e-07 è la tolleranza: tre decimilionesimi. Tanto basta per l'inezia dei numeri con la virgola, e un errore vero resta rosso.

Cosa portiamo a casa. Con i numeri con la virgola calcolati, mai ==: pytest.approx. Se scrivi una tolleranza tua (abs=0.01), tienila stretta: più è larga, più errori lascia passare.


D · L'orario che non esiste

La funzione che legge gli orari del tabellone trasforma «06:45» in minuti dalla mezzanotte. Un orario impossibile, come «25:10», deve dare ValueError.

Python
# orari.py
def ora_in_minuti(orario: str) -> int:
    """Da «06:45» ai minuti dalla mezzanotte. Un orario impossibile è un ValueError."""
    ore_testo, minuti_testo = orario.split(":")
    ore = int(ore_testo)
    minuti = int(minuti_testo)
    if ore > 23 or minuti > 59:
        raise ValueError(f"Orario impossibile: {orario}")
    return ore * 60 + minuti

Il disegno.

inizio ora_in_minuti(orario) ore_testo, minuti_testo = orario.split(":") ore = int(ore_testo) minuti = int(minuti_testo) se ore > 23 or minuti > 59 sì: errore ValueError Orario impossibile restituisci ore * 60 + minutiora_in_minuti(orario)ore_testo, minuti_testo =orario.split(":")ore = int(ore_testo)minuti = int(minuti_testo)ore > 23 or minuti >59ValueError Orarioimpossibilerestituisci ore * 60 +minutinosì
L'orario che non esiste

Nadia prova a scrivere il test dell'errore così:

Python
def test_un_orario_impossibile_e_un_errore():
    assert ora_in_minuti("25:10") == ValueError
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Rosso, e non per il motivo che pensava Nadia.

============================= test session starts ==============================
collected 1 item

test_orari.py F                                                          [100%]

=================================== FAILURES ===================================
____________________ test_un_orario_impossibile_e_un_errore ____________________

    def test_un_orario_impossibile_e_un_errore():
>       assert ora_in_minuti("25:10") == ValueError
               ^^^^^^^^^^^^^^^^^^^^^^

test_orari.py:5: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

orario = '25:10'

    def ora_in_minuti(orario: str) -> int:
        """Da «06:45» ai minuti dalla mezzanotte. Un orario impossibile è un ValueError."""
        ore_testo, minuti_testo = orario.split(":")
        ore = int(ore_testo)
        minuti = int(minuti_testo)
        if ore > 23 or minuti > 59:
>           raise ValueError(f"Orario impossibile: {orario}")
E           ValueError: Orario impossibile: 25:10

orari.py:7: ValueError
=========================== short test summary info ============================
FAILED test_orari.py::test_un_orario_impossibile_e_un_errore - ValueError: Or...
============================== 1 failed in 0.01s ===============================

L'errore è arrivato, giusto, ma l'assert non lo aspettava: ora_in_minuti("25:10") solleva l'errore prima di poter restituire qualcosa da confrontare. L'errore non è un valore: è un'interruzione. Per aspettarlo serve un attrezzo fatto apposta.

In italiano. Dico a pytest: «dentro questo blocco mi aspetto un ValueError, e nel messaggio deve comparire l'orario».

Python
import pytest
from orari import ora_in_minuti


def test_un_orario_si_converte_in_minuti():
    assert ora_in_minuti("06:45") == 405


def test_un_orario_impossibile_e_un_errore():
    with pytest.raises(ValueError, match="25:10"):
        ora_in_minuti("25:10")
============================= test session starts ==============================
collecting ... collected 2 items

test_orari.py::test_un_orario_si_converte_in_minuti PASSED               [ 50%]
test_orari.py::test_un_orario_impossibile_e_un_errore PASSED             [100%]

============================== 2 passed in 0.00s ===============================

Ora una versione sbagliata della funzione: il controllo delle ore è stato tolto (ore > 99 al posto di ore > 23). Il test con pytest.raises(ValueError) diventa rosso:

    def test_un_orario_impossibile_e_un_errore():
>       with pytest.raises(ValueError):
             ^^^^^^^^^^^^^^^^^^^^^^^^^
E       Failed: DID NOT RAISE ValueError

test_orari.py:6: Failed

DID NOT RAISE vuol dire: l'errore doveva arrivare e non è arrivato.

Passo per passo.

ScriviDoveCosa fa
raise ValueError(…)nella funzionesegnala l'errore
assert …nel testcontrolla un valore
with pytest.raises(ValueError):nel testcontrolla che l'errore arrivi

Cosa portiamo a casa. Si prova anche l'errore, con pytest.raises e il tipo preciso. Con match= provi anche il messaggio. pytest.raises(Exception) è troppo largo: prenderebbe anche un bug che non c'entra niente.


E · Le fasce orarie, ai confini

Il tabellone cambia colore secondo l'ora: notte fino alle 5 comprese, punta dalle 7 alle 9 comprese, il resto è giorno.

Python
# fasce.py
def fascia_oraria(ora: int) -> str:
    """notte fino alle 5 comprese, punta dalle 7 alle 9 comprese, poi giorno."""
    if ora <= 5:
        return "notte"
    if 7 <= ora <= 9:
        return "punta"
    return "giorno"

Il disegno.

inizio fascia_oraria(ora) se ora <= 5 sì: restituisci notte se 7 <= ora <= 9 sì: restituisci punta restituisci giornofascia_oraria(ora)ora <= 5restituisci notte7 <= ora <= 9restituisci puntarestituisci giornonosìnosì
Le fasce orarie

I valori che contano sono i confini: 5 e 6, 7, 9 e 10. Sei test quasi uguali? No: uno solo, con parametrize.

Python
import pytest
from fasce import fascia_oraria


@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
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Sei test, tutti verdi. Ognuno ha il suo nome, con i valori dentro le parentesi quadre.

============================= test session starts ==============================
collecting ... collected 6 items

test_fasce.py::test_la_fascia_cambia_ai_confini[0-notte] PASSED          [ 16%]
test_fasce.py::test_la_fascia_cambia_ai_confini[5-notte] PASSED          [ 33%]
test_fasce.py::test_la_fascia_cambia_ai_confini[6-giorno] PASSED         [ 50%]
test_fasce.py::test_la_fascia_cambia_ai_confini[7-punta] PASSED          [ 66%]
test_fasce.py::test_la_fascia_cambia_ai_confini[9-punta] PASSED          [ 83%]
test_fasce.py::test_la_fascia_cambia_ai_confini[10-giorno] PASSED        [100%]

============================== 6 passed in 0.01s ===============================

In italiano. Pytest lancia la funzione di test una volta per ogni riga della lista. La prima colonna diventa il parametro ora, la seconda il parametro fascia.

Ora qualcuno cambia il codice: 7 <= ora < 9, che toglie le 9 dalla punta. Nessun test «facile» se ne accorge: le 8 sarebbero ancora punta. Il test con i confini sì:

test_fasce.py ....F.                                                     [100%]

=================================== FAILURES ===================================
__________________ test_la_fascia_cambia_ai_confini[9-punta] ___________________

ora = 9, fascia = 'punta'

    @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
E       AssertionError: assert 'giorno' == 'punta'
E         
E         - punta
E         + giorno

test_fasce.py:17: AssertionError
=========================== short test summary info ============================
FAILED test_fasce.py::test_la_fascia_cambia_ai_confini[9-punta] - AssertionEr...
========================= 1 failed, 5 passed in 0.01s ==========================

Dei sei, uno solo è rosso, e il suo nome dice quale: [9-punta].

Passo per passo.

ConfineValori da provarePerché
notte / giorno5 e 6l'ultimo valore di notte e il primo dopo
giorno / punta6 e 7l'ultimo prima della punta e il primo dentro
punta / giorno9 e 10l'ultimo valore di punta e il primo dopo

Cosa portiamo a casa. Con parametrize aggiungere un caso costa una riga. I valori da scegliere sono quelli dove il comportamento cambia, da una parte e dall'altra.


F · Il terreno di prova

L'ultimo caso: funzioni che stampano e funzioni che scrivono un file. Non hanno un return da confrontare.

Python
# avvisi.py
from pathlib import Path


def stampa_avviso(treno: str, minuti: int) -> None:
    print(f"Il treno {treno} ha {minuti} minuti di ritardo")


def salva_ritardi(percorso: Path, ritardi: dict[str, int]) -> None:
    with open(percorso, "w", encoding="utf-8") as file:
        for treno, minuti in ritardi.items():
            file.write(f"{treno},{minuti}\n")

Tre aiutanti di pytest, chiesti per nome come parametri del test:

Python
import pytest
from avvisi import salva_ritardi, stampa_avviso


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


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"


def test_il_file_ha_una_riga_per_treno(tmp_path, ritardi):
    file = tmp_path / "ritardi.csv"
    salva_ritardi(file, ritardi)
    assert file.read_text(encoding="utf-8") == "M12,5\nT28,0\n"


def test_il_file_si_legge_riga_per_riga(tmp_path, ritardi):
    file = tmp_path / "ritardi.csv"
    salva_ritardi(file, ritardi)
    righe = file.read_text(encoding="utf-8").splitlines()
    assert righe == ["M12,5", "T28,0"]
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Tre verdi.

============================= test session starts ==============================
collecting ... collected 3 items

test_avvisi.py::test_l_avviso_dice_treno_e_minuti PASSED                 [ 33%]
test_avvisi.py::test_il_file_ha_una_riga_per_treno PASSED                [ 66%]
test_avvisi.py::test_il_file_si_legge_riga_per_riga PASSED               [100%]

============================== 3 passed in 0.01s ===============================

Il disegno.

ritardi = {"M12": 5, "T28": 0}ritardidict"M12"5"T28"0
I dati che la fixture ritardi passa ai test

In italiano.

  • capsys ascolta quello che la funzione stampa. Dopo la chiamata, capsys.readouterr().out è il testo uscito su stdout.
  • tmp_path è una cartella temporanea e vuota, solo per questo test. Ci scrivi dentro un file, ci fai lavorare la funzione, lo rileggi. Quando il test finisce, pytest la butta via.
  • ritardi è una fixture tua: la funzione con @pytest.fixture sopra restituisce i dati, e i test che la nominano come parametro li ricevono pronti. Due test, gli stessi dati, scritti una volta sola.

Cosa portiamo a casa. Per i file, tmp_path, sempre: mai un percorso scritto a mano. Per quello che una funzione stampa, capsys. Per i dati che servono a più test, una fixture.


Pronto? Gli stessi attrezzi ti aspettano nella palestra: sei esercizi da scaricare. Il codice è già scritto e giusto: i test, tocca a te.