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.
- Prima di scrivere sai già cosa vuol dire «finito»: quando il test diventa verde.
- 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:
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:
def annuncio(treno, minuti):
passAdesso 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ì:
def test_in_arrivo():
assert "in arrivo" in annuncio("M12", 0)dà questo:
E TypeError: argument of type 'NoneType' is not iterableRosso 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:
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:
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.
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:
| Mossa | Cosa fai | Cosa ti aspetti da pytest |
|---|---|---|
| Rosso | Un test nuovo | Un test rosso, per il motivo giusto |
| Verde | Il codice minimo | Tutto verde |
| Pulisci | Nomi, costanti, ripetizioni | Tutto 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:
pytest storia/test_badge.py::test_un_badge_vuoto_ha_un_errore -voppure, per nome:
pytest storia/test_badge.py -v -k vuotoI 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.
| Turno | Chi | Cosa fa |
|---|---|---|
| Rosso | Persona A | Scrive il test. Lo lancia: è rosso, per il motivo giusto |
| Verde | Persona B | Scrive il codice minimo. Pytest: tutto verde |
| Pulisci | Insieme | Sistemano il codice, pytest dopo ogni modifica |
| Dopo | B scrive il prossimo test | I 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.