Vai al contenuto
code-to-code

Apro l'indice…

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

Codice pulito e test4. Prima il testp. 117

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.

pulito-tdd-soluzioni.zip24 KB

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.

Python
def test_un_badge_vuoto_ha_un_errore():
    assert errori_badge("") == ["badge vuoto"]
Python
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.

  1. Un badge giusto non ha errori. Rosso: la funzione dà sempre «badge vuoto». Il minimo: un if sul badge vuoto, e [] per tutto il resto.
  2. Senza quattro pezzi, il formato è sbagliato. Rosso. Il minimo: dividere con split("-") e contare i pezzi.
  3. Una sigla diversa da LM è sbagliata. Rosso. Il minimo: spacchettare i pezzi e confrontare il primo.
Python
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:

Python
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.

Python
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.

Python
@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):

Python
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 sbagliatoCosa succedeIl test rosso
Nessun controllo sul reparto (la riga if reparto not in REPARTI non c'è)Un reparto inventato passa: LM-0427-MAG-3 risulta buonotest_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:

Python
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).

Python
    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):

Python
@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) == cifra

Poi il codice pulito: funzione sua, tipi, nomi che dicono cosa sono (cifra, non c), costanti in cima.

Python
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.

inizio cifra_di_controllo(numero) somma = 0 per ogni cifra in numero somma = somma + int(cifra) restituisci somma % MODULOcifra_di_controllo(numero)somma = 0per ogni cifra in numerosomma = somma + int(cifra)restituisci somma % MODULOfiniti
La cifra di controllo

Passo per passo, con il numero 0999 e il badge LM-0999-STA-7:

Girocifraint(cifra)somma dopo il giro
prima——0
1"0"00
2"9"99
3"9"918
4"9"927

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 sbagliatoCosa succedeIl test rosso
return somma senza % MODULOPer 0427 la somma è 13, ma sul badge c'è scritto 3: ogni badge con la somma oltre il nove viene bocciato, anche i buonitest_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 accorgetest_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:

Python
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.

Python
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 sbagliatoCosa succedeIl 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 è vuototest_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 minuscoleI test sono verdi sul codice giusto. Se .upper() sparisce, nessuno se ne accorgetest_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.

Python
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":

PassoCosa controllaRisultatoerrori dopo il passo
prima——[]
sigla"XX" != "LM"vero["sigla sbagliata"]
numero"12": due cifrenon valido["sigla sbagliata", "numero non valido"]
reparto"ABC" non è nella tuplavero[…, "reparto sconosciuto"]
cifranumero_valido è falsonon si controllainvariato

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:

Python
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 errori

Il disegno.

inizio errori = [] se sigla != SIGLA sì: errori.append sigla sbagliata se not numero_valido sì: errori.append numero non valido se reparto not in REPARTI sì: errori.append reparto sconosciuto se numero_valido e cifra sbagliata sì: errori.append cifra sbagliata restituisci errorierrori = []sigla != SIGLAerrori.append siglasbagliatanot numero_validoerrori.append numero nonvalidoreparto not inREPARTIerrori.append repartosconosciutonumero_valido ecifra sbagliataerrori.append cifrasbagliatarestituisci errorinosìnosìnosìnosì
I controlli che si sommano

Le trappole.

Il codice sbagliatoCosa succedeIl 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 maitest_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 alfabeticotest_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-5 ha 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.
Terminale
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.»