Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test4. Prima il testp. 99

Prima il test

Rosso, verde, pulisci. E il ping-pong

  • 10 minuti di lettura

Finora hai scritto il codice e poi, forse, un test per controllarlo. In questo capitolo si fa al contrario: prima il test, poi il codice.

Sembra strano, e ha due buoni motivi.

  1. Prima di scrivere sai già cosa vuol dire «finito»: quando il test diventa verde.
  2. Un test nato rosso ti ha già dimostrato che sa diventare rosso. È proprio la regola del capitolo sui test: un test serve se si accorge dell'errore.

Questo modo di lavorare si chiama TDD, test-driven development: sviluppo guidato dai test. Non è magia, è un giro di tre mosse.

Il disegno

        ┌────────────────────────────────────────────┐
        │                                            │
        ▼                                            │
   ┌─────────┐      ┌─────────┐      ┌──────────┐    │
   │  ROSSO  │ ───▶ │  VERDE  │ ───▶ │ PULISCI  │ ───┘
   └─────────┘      └─────────┘      └──────────┘
   un test nuovo    il codice        stesso
   che fallisce     minimo che       comportamento,
   (per il motivo   lo fa passare    forma migliore
   giusto)

Ogni giro è piccolo: pochi minuti, una regola, un test. Poi si ricomincia.

Rosso

Scrivi un test, per una regola, con un esempio preciso. Lo lanci. Deve fallire.

Ma non basta che fallisca: deve fallire per il motivo previsto. Facciamo finta di costruire l'annuncio del tabellone: annuncio("M12", 0) deve dare "Il treno M12 è in arrivo.". Il test:

Python
from annunci import annuncio


def test_con_zero_minuti_il_treno_e_in_arrivo():
    assert annuncio("M12", 0) == "Il treno M12 è in arrivo."
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.

Il file annunci.py non esiste ancora. Cosa dice pytest?

E   ModuleNotFoundError: No module named 'annunci'

È rosso, ma è un rosso sbagliato: il test non è nemmeno partito. Non ti ha detto niente sul codice, solo che manca un file.

Crei annunci.py con la funzione vuota:

Python
def annuncio(treno, minuti):
    pass

Adesso il test parte, e fallisce così:

>       assert annuncio("M12", 0) == "Il treno M12 è in arrivo."
E       AssertionError: assert None == 'Il treno M12 è in arrivo.'
E        +  where None = annuncio('M12', 0)

Questo è il rosso giusto: la funzione c'è, e risponde None al posto di quello che ci aspettiamo. Il test sta dicendo proprio quello che manca.

C'è anche un secondo rosso sbagliato, più furbo. Con la funzione vuota, un test scritto così:

Python
def test_in_arrivo():
    assert "in arrivo" in annuncio("M12", 0)

dà questo:

E       TypeError: argument of type 'NoneType' is not iterable

Rosso anche lui, ma per un motivo che non c'entra con la regola. Un confronto con == ti dà quasi sempre un rosso più chiaro.

Verde

Scrivi il codice minimo che fa passare il test. Minimo davvero:

Python
def annuncio(treno, minuti):
    return "Il treno M12 è in arrivo."

Sembra barare, vero? Restituisce proprio la frase del test, per il treno M12, e basta. Eppure il test è verde, ed è il verde giusto: hai appena dimostrato che la strada funziona.

Il codice che bara è anche il motivo per cui scrivi il secondo test.

Il secondo test costringe il codice a crescere

Un test solo non basta a farti scrivere il codice vero. Il secondo, con un altro treno:

Python
def test_il_codice_del_treno_cambia_nell_annuncio():
    assert annuncio("T28", 0) == "Il treno T28 è in arrivo."

È rosso: la frase fissa dice M12, non T28. E adesso, per farlo passare, non si può più barare: serve una f-string.

Python
def annuncio(treno, minuti):
    return f"Il treno {treno} è in arrivo."

È il modo in cui i test «tirano fuori» il codice: ogni test nuovo toglie una scorciatoia. Quando il codice è già abbastanza generale, un test nuovo nasce verde, e non è un guaio: vuol dire che quel caso era già coperto. (Se invece ti aspettavi il rosso e non è arrivato, controlla che il test provi davvero quello che pensi.)

Pulisci

Con tutto verde, e solo allora, sistemi il codice: nomi, numeri senza un nome, pezzi ripetuti. Sono le sette regole, e il modo di farlo è quello di rifattorizzare senza rompere: un cambiamento piccolo, poi pytest.

Perché solo sul verde? Perché i test sono la tua rete di sicurezza. Se un test è già rosso e tu intanto riscrivi il codice, quando poi si rompe qualcosa non sai se è colpa del nuovo test o della pulizia. Con tutto verde, un rosso arriva da una cosa sola: l'ultima modifica.

Ogni giro, quindi:

MossaCosa faiCosa ti aspetti da pytest
RossoUn test nuovoUn test rosso, per il motivo giusto
VerdeIl codice minimoTutto verde
PulisciNomi, costanti, ripetizioniTutto verde, dopo ogni modifica

Un rosso alla volta

Se scrivi tre test insieme e poi sono tutti rossi, non sai da dove cominciare. Una regola semplice: un test nuovo alla volta, e un solo rosso sullo schermo.

Per guardare un test solo, senza gli altri:

Terminale
pytest storia/test_badge.py::test_un_badge_vuoto_ha_un_errore -v

oppure, per nome:

Terminale
pytest storia/test_badge.py -v -k vuoto

I due modi per lanciare i test sono in Lanciare i test. E dopo ogni verde, un commit: con Il giro di ogni giorno hai già tutto quello che serve. Un giro, un commit: se qualcosa si rompe, torni all'ultimo verde.

Il ping-pong

Il TDD si può fare anche in due, ed è un gioco con due ruoli.

TurnoChiCosa fa
RossoPersona AScrive il test. Lo lancia: è rosso, per il motivo giusto
VerdePersona BScrive il codice minimo. Pytest: tutto verde
PulisciInsiemeSistemano il codice, pytest dopo ogni modifica
DopoB scrive il prossimo testI ruoli si scambiano: la tastiera passa di mano a ogni rosso

La regola d'oro: chi scrive il test non scrive il codice. Così il test non è fatto su misura per il codice che hai già in testa, e chi scrive il codice non può «barare» in silenzio: deve far passare il test di un altro.

In coppia, ognuno al suo computer? VS Code ha Live Share, che fa scrivere due persone sullo stesso file a distanza: lo trovi in VS Code per Python. Se siete vicini, basta una tastiera che gira.

Quando conviene

Il TDD non è un obbligo. È più utile quando le regole sono tante e precise (come in un validatore), e meno quando non sai ancora cosa vuoi ottenere. Nel capitolo lo usi per costruire, regola per regola, il validatore dei badge del personale: nella pagina Esercizi spiegati vedi un ping-pong intero, e nella Storia tocca a te.

Ricorda

  • Il giro è rosso, verde, pulisci: un test che fallisce, il codice minimo, poi la forma.
  • Il rosso deve essere giusto: fallisce perché il risultato è sbagliato, non perché il file manca o il test è scritto male.
  • Il verde è minimo: anche una frase fissa va bene, finché il test seguente non la rompe.
  • Il secondo test costringe il codice a diventare vero.
  • Si pulisce solo sul verde, e pytest dopo ogni modifica.
  • Un rosso alla volta; un test solo con :: o con -k.
  • Ping-pong: chi scrive il test non scrive il codice, e la tastiera passa a ogni rosso.