Prima il test, le soluzioni
I test nell'ordine in cui nascono, il codice dopo ogni pulisci, le trappole
Per ogni livello, sempre lo stesso ordine: in italiano → i test, nell'ordine in cui sono nati → il codice dopo il verde e dopo il pulisci → le trappole. Per i livelli più difficili, anche il passo per passo.
La tua soluzione è diversa ma i controlli sono verdi? Probabilmente va bene: i test di ognuno sono un po' diversi, e il codice minimo dipende da quello che hai scritto prima. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano molti test e si rompono su uno solo.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
Livello 1 · Il badge vuoto
In italiano. Il test c'è già, ed è rosso per il motivo giusto (None al posto di ["badge vuoto"]). Il codice minimo: la lista fissa.
def test_un_badge_vuoto_ha_un_errore():
assert errori_badge("") == ["badge vuoto"]def errori_badge(codice):
return ["badge vuoto"]Non c'è niente da pulire: due righe. Il verde «che bara», per ora, va bene.
Livello 2 · Il formato e la sigla
In italiano. Tre test, tre giri.
- Un badge giusto non ha errori. Rosso: la funzione dà sempre «badge vuoto». Il minimo: un
ifsul badge vuoto, e[]per tutto il resto. - Senza quattro pezzi, il formato è sbagliato. Rosso. Il minimo: dividere con
split("-")e contare i pezzi. - Una sigla diversa da LM è sbagliata. Rosso. Il minimo: spacchettare i pezzi e confrontare il primo.
def test_un_badge_giusto_non_ha_errori():
assert errori_badge("LM-0427-DEP-3") == []
def test_senza_quattro_pezzi_il_formato_e_sbagliato():
assert errori_badge("LM-0427") == ["formato sbagliato"]
assert errori_badge("LM0427DEP3") == ["formato sbagliato"]
def test_una_sigla_diversa_da_lm_e_sbagliata():
assert errori_badge("XX-0427-DEP-3") == ["sigla sbagliata"]Il codice dopo il terzo verde:
def errori_badge(codice):
if codice == "":
return ["badge vuoto"]
pezzi = codice.split("-")
if len(pezzi) != 4:
return ["formato sbagliato"]
sigla, numero, reparto, cifra = pezzi
if sigla != "LM":
return ["sigla sbagliata"]
return []Poi pulisci: il 4 e l'"LM" sono numeri e testi senza un nome, e mancano i tipi.
SIGLA = "LM"
PEZZI_DEL_BADGE = 4
def errori_badge(codice: str) -> list[str]:
if codice == "":
return ["badge vuoto"]
pezzi = codice.split("-")
if len(pezzi) != PEZZI_DEL_BADGE:
return ["formato sbagliato"]
sigla, numero, reparto, cifra = pezzi
if sigla != SIGLA:
return ["sigla sbagliata"]
return []Il test della sigla controlla ["sigla sbagliata"] da sola, con un esempio in cui il resto è giusto (0427, DEP, cifra 3): così non dipende dalle regole che arrivano dopo.
Livello 3 · Il numero e il reparto
In italiano. Più casi per regola, quindi parametrize: lo stesso test con tanti valori.
@pytest.mark.parametrize("numero", ["427", "04271", "04A7"])
def test_un_numero_che_non_e_di_quattro_cifre_non_e_valido(numero):
assert errori_badge(f"LM-{numero}-DEP-3") == ["numero non valido"]
@pytest.mark.parametrize("reparto", ["MAG", "DEP1", "D"])
def test_un_reparto_fuori_dall_elenco_e_sconosciuto(reparto):
assert errori_badge(f"LM-0427-{reparto}-3") == ["reparto sconosciuto"]
@pytest.mark.parametrize("reparto", ["DEP", "TRE", "STA", "SIC"])
def test_i_quattro_reparti_vanno_bene(reparto):
assert errori_badge(f"LM-0427-{reparto}-3") == []Il codice (le tre costanti sono già al loro posto: il livello 3 aggiunge le ultime due righe di controllo):
SIGLA = "LM"
REPARTI = ("DEP", "TRE", "STA", "SIC")
PEZZI_DEL_BADGE = 4
CIFRE_DEL_NUMERO = 4
def errori_badge(codice: str) -> list[str]:
if codice == "":
return ["badge vuoto"]
pezzi = codice.split("-")
if len(pezzi) != PEZZI_DEL_BADGE:
return ["formato sbagliato"]
sigla, numero, reparto, cifra = pezzi
if sigla != SIGLA:
return ["sigla sbagliata"]
if len(numero) != CIFRE_DEL_NUMERO or not numero.isdigit():
return ["numero non valido"]
if reparto not in REPARTI:
return ["reparto sconosciuto"]
return []Il numero è valido solo se tutte e due le cose sono vere: quattro cifre e tutte cifre. Per questo il test prova 427 (poche), 04271 (troppe) e 04A7 (una lettera): ognuno ha rotto una metà della condizione.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Nessun controllo sul reparto (la riga if reparto not in REPARTI non c'è) | Un reparto inventato passa: LM-0427-MAG-3 risulta buono | test_un_reparto_fuori_dall_elenco_e_sconosciuto e, più avanti, test_gli_errori_si_danno_tutti_nell_ordine_delle_regole |
Livello 4 · La cifra di controllo
In italiano. Prima la cifra: un test, poi il codice. Poi si estrae il calcolo in una funzione sua, con i suoi test, e si dà un nome a ogni numero.
I test, nell'ordine:
def test_una_cifra_sbagliata_e_segnalata():
assert errori_badge("LM-0427-DEP-4") == ["cifra di controllo sbagliata"]
def test_una_cifra_che_non_e_una_cifra_e_sbagliata():
assert errori_badge("LM-0427-DEP-X") == ["cifra di controllo sbagliata"]
def test_con_il_numero_non_valido_la_cifra_non_si_controlla():
assert errori_badge("LM-427-DEP-9") == ["numero non valido"]Il codice dopo il verde: il calcolo è tutto dentro errori_badge, con una c al posto della cifra (e il 10 già chiamato MODULO).
somma = 0
for c in numero:
somma = somma + int(c)
if cifra != str(somma % MODULO):
return ["cifra di controllo sbagliata"]Funziona, ma errori_badge si allunga e c non dice niente: pulisci. I test della funzione nuova (nati prima di spostare il codice):
@pytest.mark.parametrize(
"numero, cifra",
[("0427", 3), ("1111", 4), ("0000", 0), ("0999", 7)],
)
def test_la_cifra_di_controllo_e_la_somma_modulo_dieci(numero, cifra):
assert cifra_di_controllo(numero) == cifraPoi il codice pulito: funzione sua, tipi, nomi che dicono cosa sono (cifra, non c), costanti in cima.
SIGLA = "LM"
REPARTI = ("DEP", "TRE", "STA", "SIC")
PEZZI_DEL_BADGE = 4
CIFRE_DEL_NUMERO = 4
MODULO = 10
def cifra_di_controllo(numero: str) -> int:
"""La cifra di controllo di un numero di quattro cifre: la somma delle sue cifre, modulo 10."""
somma = 0
for cifra in numero:
somma = somma + int(cifra)
return somma % MODULO
def errori_badge(codice: str) -> list[str]:
if codice == "":
return ["badge vuoto"]
pezzi = codice.split("-")
if len(pezzi) != PEZZI_DEL_BADGE:
return ["formato sbagliato"]
sigla, numero, reparto, cifra = pezzi
if sigla != SIGLA:
return ["sigla sbagliata"]
if len(numero) != CIFRE_DEL_NUMERO or not numero.isdigit():
return ["numero non valido"]
if reparto not in REPARTI:
return ["reparto sconosciuto"]
if cifra != str(cifra_di_controllo(numero)):
return ["cifra di controllo sbagliata"]
return []Il disegno.
Passo per passo, con il numero 0999 e il badge LM-0999-STA-7:
| Giro | cifra | int(cifra) | somma dopo il giro |
|---|---|---|---|
| prima | — | — | 0 |
| 1 | "0" | 0 | 0 |
| 2 | "9" | 9 | 9 |
| 3 | "9" | 9 | 18 |
| 4 | "9" | 9 | 27 |
Alla fine 27 % 10 fa 7. Il badge ha scritto 7 in fondo: nessun errore. Con str(...), perché nel badge la cifra è un testo.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
return somma senza % MODULO | Per 0427 la somma è 13, ma sul badge c'è scritto 3: ogni badge con la somma oltre il nove viene bocciato, anche i buoni | test_la_cifra_di_controllo_e_la_somma_modulo_dieci, test_un_badge_giusto_non_ha_errori, e con loro altri cinque test che usano il numero 0427 |
Una suite in cui la cifra si prova solo su badge buoni (mai LM-0427-DEP-4) | La funzione cifra_di_controllo è provata, ma se la regola sparisce da errori_badge nessun test se ne accorge | test_livello_4_i_tuoi_test_controllano_la_cifra (il controllo) |
La prima è il risultato di una scorciatoia: «la cifra è la somma». Una somma di quattro cifre arriva anche a 36: sul badge ne entra una sola.
La seconda è la trappola dei test «solo casi felici»: sono verdi sul codice giusto, ma verdi anche sul codice senza la regola. Un test che non può diventare rosso non prova niente (è l'idea del capitolo sui test): per questo i controlli provano i tuoi test su versioni sbagliate apposta.
Livello 5 · Gli spazi e le minuscole
In italiano. Il caso arriva dai dati veri: python storia/badge.py mostra un badge con lo spazio davanti, bocciato per la sigla. Prima il test che lo riproduce:
def test_gli_spazi_ai_lati_non_contano():
assert errori_badge(" LM-0427-DEP-3 ") == []
def test_le_minuscole_non_contano():
assert errori_badge("lm-0427-dep-3") == []
def test_un_badge_di_soli_spazi_e_vuoto():
assert errori_badge(" ") == ["badge vuoto"]Rosso (con lo spazio, la sigla è " LM"). Il minimo: sistemare il badge prima di tutto il resto, e usare la versione sistemata da lì in poi.
def errori_badge(codice: str) -> list[str]:
badge = codice.strip().upper()
if badge == "":
return ["badge vuoto"]
pezzi = badge.split("-")
...Il resto del codice è identico a prima (qui ...). L'ultimo test funziona perché il controllo del vuoto viene dopo strip().
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
if codice == "" e codice.split("-"), senza sistemare niente | " LM-0318-TRE-2" ha la sigla " LM"; "lm-0642-sic-2" ha sigla e reparto sbagliati; " " non è vuoto | test_gli_spazi_ai_lati_non_contano, test_le_minuscole_non_contano, test_un_badge_di_soli_spazi_e_vuoto |
| Una suite con gli spazi ma senza il test delle minuscole | I test sono verdi sul codice giusto. Se .upper() sparisce, nessuno se ne accorge | test_livello_5_i_tuoi_test_provano_le_minuscole (il controllo) |
La seconda trappola è il motivo per cui il controllo vuole due test separati: uno solo coprirebbe una metà della regola.
Livello 6 · Tutti gli errori insieme
In italiano. Fin qui ogni errore ha un return: il codice si ferma al primo. Il test nuovo lo smaschera: un badge con tre errori deve dare tutti e tre.
def test_gli_errori_si_danno_tutti_nell_ordine_delle_regole():
assert errori_badge("XX-12-ABC-5") == [
"sigla sbagliata",
"numero non valido",
"reparto sconosciuto",
]
def test_la_sigla_e_la_cifra_sbagliate_insieme():
assert errori_badge("XX-0427-DEP-4") == [
"sigla sbagliata",
"cifra di controllo sbagliata",
]Rosso (["sigla sbagliata"]: si è fermato subito). Il verde minimo: una lista errori, un append al posto di ogni return, e il return solo in fondo.
Passo per passo, con "XX-12-ABC-5":
| Passo | Cosa controlla | Risultato | errori dopo il passo |
|---|---|---|---|
| prima | — | — | [] |
| sigla | "XX" != "LM" | vero | ["sigla sbagliata"] |
| numero | "12": due cifre | non valido | ["sigla sbagliata", "numero non valido"] |
| reparto | "ABC" non è nella tupla | vero | […, "reparto sconosciuto"] |
| cifra | numero_valido è falso | non si controlla | invariato |
La cifra non entra: con il numero non valido non c'è niente da sommare. Per questo c'è numero_valido, calcolato una volta e usato due volte.
Il codice finale, dopo l'ultimo pulisci:
def errori_badge(codice: str) -> list[str]:
badge = codice.strip().upper()
if badge == "":
return ["badge vuoto"]
pezzi = badge.split("-")
if len(pezzi) != PEZZI_DEL_BADGE:
return ["formato sbagliato"]
sigla, numero, reparto, cifra = pezzi
errori = []
if sigla != SIGLA:
errori.append("sigla sbagliata")
numero_valido = len(numero) == CIFRE_DEL_NUMERO and numero.isdigit()
if not numero_valido:
errori.append("numero non valido")
if reparto not in REPARTI:
errori.append("reparto sconosciuto")
# Con un numero non valido non c'è niente da sommare: la cifra non si controlla.
if numero_valido and cifra != str(cifra_di_controllo(numero)):
errori.append("cifra di controllo sbagliata")
return erroriIl disegno.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Il return al primo errore (return ["sigla sbagliata"] dentro l'if) | XX-12-ABC-5 dà solo la sigla: gli altri due errori non si vedono mai | test_gli_errori_si_danno_tutti_nell_ordine_delle_regole, test_la_sigla_e_la_cifra_sbagliate_insieme |
| Una suite con un errore alla volta (mai un badge con due errori) | I test sono verdi anche sul codice che si ferma al primo errore, e su quello che li mette in ordine alfabetico | test_livello_6_i_tuoi_test_provano_piu_errori_insieme e test_livello_6_i_tuoi_test_provano_l_ordine_degli_errori (i controlli) |
Il finale
Il quaderno, con il codice finale (alcune righe tolte):
$ python storia/badge.py
'LM-0757-DEP-9' []
'LM-0863-DEP-5' ['cifra di controllo sbagliata']
' LM-0318-TRE-2' []
'LX-0531-TRE-9' ['sigla sbagliata']
'lm-0642-sic-2' []
'' ['badge vuoto']
'LM0757DEP9' ['formato sbagliato']
'LM-0204-MAG-5' ['reparto sconosciuto', 'cifra di controllo sbagliata']
'LM-531-TRE-9' ['numero non valido']
'XX-12-ABC-5' ['sigla sbagliata', 'numero non valido', 'reparto sconosciuto']Un solo badge ha come unico errore la cifra: LM-0863-DEP-5. La cifra giusta, per 0863, sarebbe 8 + 6 + 3 = 17, cioè 7. Il falsario ha scritto 5. Il numero 0863 è, in PERSONALE, di Elisa Fontana.
Gli altri sospetti nascono da un errore nel codice:
LM-0204-MAG-5ha due errori, il reparto e la cifra. Se hai dimenticato il reparto (livello 3), la cifra sembra l'unico errore: e il suo numero,0204, è di Ivo Brambati.LM-0757-DEP-9è buono: 7 + 5 + 7 = 19, e la cifra è l'ultima, 9. Se hai dimenticato il resto della divisione per dieci (livello 4), lo boccia: è di Ernesto Pozzi." LM-0318-TRE-2"(lo spazio) e"lm-0642-sic-2"(le minuscole) sono buoni. Senza il livello 5 sembrano falsi: sono di Marta Villa e Tommaso Greco.
python storia/verifica.py "Elisa Fontana"Ernesto Pozzi si toglie gli occhiali e guarda il quaderno a lungo.
«Giusto. Il falsario conosceva il formato, ma non la cifra di controllo.»
«Avvisate il commissario Mapelli: per i badge nuovi, adesso, il cancello ha un guardiano.»