Aller au contenu
English

Choisir des vérifications utiles

  • Leçon 12
  • 45 min
  • Module 4 : Déboguer et tester avec l'assistant

Où nous en sommes

Dans la dernière leçon, nous avons corrigé le bogue de Grace avec un test de régression qui échouait d'abord. Maintenant, Tomás demande à l'assistant d'écrire le reste des tests. Mais des tests dont les valeurs attendues viennent du code ne peuvent qu'être d'accord avec lui, bogues compris. Dans cette leçon, nous gardons les tests dont les réponses viennent de l'exigence, et nous vérifions chacun sur le code non corrigé et sur le code corrigé, en partant d'un corrigé copié sur la copie d'un élève.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Gardez les tests qui vérifient les besoins de l’utilisateur. Supprimez ceux qui ne font que répéter le code. Vérifiez chaque nouveau test : il échoue sur le code non corrigé et réussit sur le code corrigé.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 45 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet ~/projects/ticket-cleaner-assist avec la correction dans un commit : 35 passed (35 tests réussis), git status sans changements, l’environnement actif.
  • La copie ~/projects/ticket-cleaner-check de Reproduire d’abord, pour l’exercice du module. Si vous l’avez supprimée, recréez-la avec les étapes 6 et 7 de cette leçon.

Une enseignante n’a pas le temps de préparer le corrigé d’un examen de mathématiques. Elle prend donc la copie du premier élève et en copie les réponses dans le corrigé. Ensuite, elle note toutes les copies avec ce corrigé.

Le premier élève obtient 100 %, même pour ses deux mauvaises réponses. Tous les élèves qui ont fait les mêmes erreurs obtiennent aussi 100 %. Un élève qui a répondu correctement à ces deux questions perd des points.

Le corrigé semble complet : il contient une réponse à chaque question. Il est inutile, car il vient de la copie qu’il devrait vérifier. Un vrai corrigé vient de la matière : de ce qu’est la bonne réponse.

Tomás propose : « L’assistant a corrigé le problème. Laissons-le écrire les tests aussi. » L’équipe du cours a enregistré cette demande sur le code non corrigé, avant que quelqu’un trouve la cause (transcription tests-mirror) :

Prompt
Write tests for clean_category in ticket_cleaner/parsing.py.
What the assistant printed (part)
I'll add direct tests for alias normalization, whitespace trimming, preserving unrecognized category names, and converting non-string inputs to text. No
production changes are needed.

Il a ajouté 11 cas de test, et ils ont tous réussi : 35 passed. Cela semble être du bon travail. Lisez maintenant deux de ces cas :

tests/test_parsing.py (two cases from the session)
(" Custom Category ", "Custom Category"),
@pytest.mark.parametrize(("value", "expected"), [(123, "123"), (None, "None")])

" Custom Category " devient "Custom Category" : les espaces disparaissent, les majuscules restent. C’est le bogue de Grace, inscrit comme résultat attendu. L’assistant l’a même nommé : « conserver les noms de catégories non reconnus ». Il a lu le code, observé ce qu’il fait et écrit des tests qui disent « faites cela ».

L’équipe du cours a exécuté les 11 cas sur le code non corrigé et sur le code corrigé. Aucun ne détecte le bogue : ils réussissent tous sur le code non corrigé. Deux échouent après la correction : ces deux-là. Les tests ne protègent donc pas la correction. Ils s’y opposent. Avec ces tests dans le projet, la bonne correction ressemble à une erreur.

L’idée : une vérification dont la réponse vient de l’exigence

Section intitulée « L’idée : une vérification dont la réponse vient de l’exigence »

Un test compare ce que fait le code à une valeur attendue. Un test est utile quand sa valeur attendue vient de l’exigence. Il s’agit du besoin de l’utilisateur, du contenu du rapport de bogue ou des garanties du reste du programme. Un test dont la valeur attendue vient du code testé ne peut qu’approuver ce code : il répète l’implémentation. Appelons-le un test miroir, car il renvoie au code sa propre image.

Pour un bogue, trois types de vérifications utiles se complètent :

  1. Le test de régression. L’entrée minimale qui provoque l’échec, avec la valeur attendue du rapport de bogue. Il doit échouer sur le code non corrigé.
  2. Les cas limites. Les cas proches du bogue : d’autres écritures, des espaces, une majuscule dans un nom de formulaire Web. Certains échouent sur le code non corrigé; d’autres réussissent sur les deux versions et protègent le comportement existant.
  3. L’exigence du point de vue de l’utilisateur. La commande de Grace sur son propre fichier, par le point d’entrée du programme. Elle vérifie tout le parcours, pas une seule fonction.

Ensuite, vérifiez chaque nouveau test : exécutez-le sur le code non corrigé et sur le code corrigé. Un test qui échoue avant et réussit après détecte le bogue. Un test qui réussit sur les deux préserve le comportement existant. C’est utile, mais cela ne prouve rien sur la correction. Un test qui réussit avant et échoue après répète le bogue : supprimez-le ou corrigez sa valeur attendue selon l’exigence.

Un petit exemple : deux sources pour une valeur attendue

Section intitulée « Un petit exemple : deux sources pour une valeur attendue »

Prenez une entrée, " Custom Category ", et posez deux questions. Que renvoie le code? Et que devrait-il renvoyer?

Le code avant la correction conserve les majuscules, et le code après la correction ne les conserve pas. L’équipe du cours a exécuté les deux versions :

clean_category(' Custom Category ') and clean_category(None)
before the fix: 'Custom Category' 'None'
after the fix: 'custom category' ''

L’exigence est dans le rapport de bogue : « Les majuscules et les espaces autour d’une catégorie ne créent pas une nouvelle catégorie, comme pour le statut et l’identifiant. » La valeur attendue est donc 'custom category'. Elle vient de l’exigence, pas d’une des versions du code.

Et None? Interrogez le programme, pas la fonction. Une ligne sans catégorie n’atteint jamais clean_category() :

Fenêtre de terminal
python -c "from ticket_cleaner.parsing import split_records; print(split_records([{'id': 'T-1', 'status': 'open', 'category': None, 'priority': '1'}])[1])"
Sortie
[Rejected(row=1, problems=['missing category'])]

find_problems() la rejette d’abord. Aucune exigence ne précise donc ce que renvoie clean_category(None). Le test a fixé une valeur que le programme n’utilise jamais. Il a échoué quand un détail sans rapport a changé.

Un tableau de trois sources d'une valeur attendue, chacune avec de vrais cas de test des deux séances enregistrées. Le code testé, ce qu'il renvoie aujourd'hui : clean_category de Custom Category avec des espaces donne Custom Category, et clean_category de None donne le texte None; réussite sur le code non corrigé, échec sur le code corrigé; le test répète le bogue. Une partie du code qui fonctionne déjà : clean_category de Sign-in donne login, et de billing avec des espaces donne billing; réussite sur les deux; cela préserve le comportement existant, mais ne peut pas révéler ce bogue. L'exigence, le résultat attendu du rapport de bogue : to_ticket avec la catégorie LOGIN avec des espaces donne login; échec sur le code non corrigé, réussite sur le code corrigé; le test détecte le bogue et prouve la correction. En bas : un test dont la valeur attendue vient du code ne peut qu'approuver le code.
Demandez d'où vient chaque valeur attendue. Seule une valeur attendue tirée de l'exigence peut contredire le code et ainsi détecter un bogue.
Description textuelle du diagramme

Le diagramme est un tableau de trois sources d’une valeur attendue. Chacune contient de vrais cas de test des deux séances enregistrées, exécutés sur clean_category() avant et après la correction.

  1. Le code testé, ce qu’il renvoie aujourd’hui. Exemples : clean_category(' Custom Category ') → 'Custom Category', et clean_category(None) → 'None'. Non corrigé : réussite; corrigé : échec. Le test répète le bogue : il échoue quand le bogue est corrigé.
  2. Une partie du code qui fonctionne déjà. Exemples : clean_category('Sign-in') → 'login', et clean_category(' billing ') → 'billing'. Réussite sur les deux. Le test préserve le comportement existant, mais ne peut pas révéler ce bogue.
  3. L’exigence, le résultat « Expected » (attendu) du rapport de bogue. Exemple : to_ticket(…) avec la catégorie ' LOGIN ' → 'login'. Non corrigé : échec; corrigé : réussite. Le test détecte le bogue et prouve la correction.

En bas : un test dont la valeur attendue vient du code ne peut qu’approuver le code.

La troisième ligne vient d’une deuxième séance. L’équipe du cours a donné au même assistant le courriel de Grace et les deux lignes. Elle a demandé « un test dans tests/test_parsing.py qui échoue sur le code actuel à cause de ce bogue, et réussit quand le bogue est corrigé » (transcription tests-failing-first). Il a écrit un test. Ce test a échoué avant la correction et réussi après. Même modèle, même fonction : la différence était l’exigence dans la requête (prompt).

Maintenant, prédisez les résultats, puis exécutez vous-même les 12 cas des deux séances :

Explorer

Quels tests générés détectent le bogue de Grace?

Les résultats de chaque cas de test sur le code non corrigé et sur le code corrigé, mesurés par l’équipe du cours.

Les 12 cas de test des deux sessions enregistrées
Cas de test et valeur attendueConsigneCode non corrigéCode corrigéVerdict
clean_category('Sign-in')
→ 'login'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category('log-in')
→ 'login'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(' sign-in ')
→ 'login'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(' LOG-IN ')
→ 'login'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category('billing')
→ 'billing'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(' billing ')
→ 'billing'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(' Custom Category ')
→ 'Custom Category'« Write tests for clean_category »
« Write tests for clean_category »réussiéchouéreprend le bogue
clean_category('')
→ ''« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(' \t\n ')
→ ''« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(123)
→ '123'« Write tests for clean_category »
« Write tests for clean_category »réussiréussiréussit sur les deux
clean_category(None)
→ 'None'« Write tests for clean_category »
« Write tests for clean_category »réussiéchouéreprend le bogue
to_ticket(… category ' LOGIN ' …).category
→ 'login'« un test qui échoue à cause du bogue »
« un test qui échoue à cause du bogue »échouéréussidétecte le bogue
Onze cas issus de la requête « Écrivez des tests pour clean_category », un issu de la requête demandant un test qui échoue à cause du bogue. Résultats mesurés par l'équipe du cours sur le code non corrigé et le code corrigé.
Description textuelle de l’explorateur

L’explorateur présente les 12 cas de test de deux séances enregistrées. Chaque cas montre l’appel, la valeur attendue par le test et la requête qui l’a produit. Deux boutons exécutent les cas sur le code non corrigé et sur le code corrigé. Une fois les deux exécutions terminées, une colonne de verdict apparaît.

Les résultats mesurés par l’équipe du cours :

  • 11 cas issus de « Écrivez des tests pour clean_category ». 9 réussissent sur les deux versions : les quatre noms de formulaire Web ('Sign-in', 'log-in', ' sign-in ', ' LOG-IN ' → 'login'), 'billing' et ' billing ' → 'billing', '' et ' \t\n ' → '', et 123 → '123'. 2 réussissent sur le code non corrigé et échouent sur le code corrigé : ' Custom Category ' → 'Custom Category' et None → 'None'. Aucun des 11 ne détecte le bogue.
  • 1 cas issu de la requête demandant un test qui échoue à cause du bogue : to_ticket(…) avec la catégorie ' LOGIN ' → 'login'. Il échoue sur le code non corrigé et réussit sur le code corrigé : il détecte le bogue.

Résumé : 1 cas détecte le bogue, 2 cas répètent le bogue, 9 cas réussissent sur les deux versions.

Vous appliquez temporairement les tests miroirs, les exécutez sur les deux versions du code, puis les supprimez. Ensuite, vous ajoutez les tests du module et vérifiez chacun d’eux. git restore --source=HEAD~1 remet un fichier dans son état d’il y a un commit, celui avant votre correction. Cette commande change seulement le fichier dans votre dossier, pas l’historique.

  1. Appliquez les tests de la séance, à partir du dossier des exercices :

    Fenêtre de terminal
    git apply ../nextia-learning-labs/C15/transcripts/tests-mirror.patch
    git diff --stat
    python -m pytest
    Sortie (extrait)
    tests/test_parsing.py | 31 ++++++++++++++++++++++++++++++-
    1 file changed, 30 insertions(+), 1 deletion(-)
    E AssertionError: assert 'custom category' == 'Custom Category'
    E AssertionError: assert '' == 'None'
    FAILED tests/test_parsing.py::test_clean_category_trims_text_without_changing_unrecognized_names[ Custom Category -Custom Category]
    FAILED tests/test_parsing.py::test_clean_category_converts_non_string_values_to_text[None-None]
    ========================= 2 failed, 44 passed in 0.05s =========================

    Sur votre code corrigé, deux des nouveaux cas échouent. Votre test de régression réussit.

  2. Rétablissez le fichier parsing.py non corrigé et exécutez les tests à nouveau :

    Fenêtre de terminal
    git restore --source=HEAD~1 ticket_cleaner/parsing.py
    python -m pytest
    python -m pytest -k clean_category
    Output (the last lines)
    FAILED tests/test_parsing.py::test_capital_letters_do_not_make_a_new_category
    ========================= 1 failed, 45 passed in 0.04s =========================
    ====================== 11 passed, 35 deselected in 0.03s =======================

    Sur le code non corrigé, seul votre test de régression échoue. -k clean_category sélectionne les 11 cas de la séance dont les noms contiennent clean_category : les 11 réussissent. Aucun ne détecte le bogue.

  3. Supprimez les tests de la séance et rétablissez le code corrigé :

    Fenêtre de terminal
    git restore ticket_cleaner/parsing.py tests/test_parsing.py
    git status --short
    python -m pytest

    git status --short n’affiche rien, et les tests donnent 35 passed.

Passons aux tests du module. Vous avez déjà le test de régression. Ajoutez les cas limites et l’exigence du point de vue de Grace.

  1. Ouvrez tests/test_parsing.py. Après test_capital_letters_do_not_make_a_new_category, ajoutez les cas limites :

    tests/test_parsing.py (new test)
    @pytest.mark.parametrize(
    ("name", "expected"),
    [("Billing ", "billing"), ("LOGIN", "login"), (" SIGN-IN", "login")],
    )
    def test_category_is_cleaned_like_the_other_fields(valid_raw, name, expected):
    valid_raw["category"] = name
    assert to_ticket(valid_raw).category == expected

    Chaque valeur attendue vient de la règle du rapport de bogue. "Billing " est l’écriture du billet T-3010 dans l’exportation de Grace. " SIGN-IN" est un nom de formulaire Web avec des majuscules et un espace : il fonctionnait avant la correction et doit encore fonctionner.

  2. Ouvrez tests/test_cli.py. À la fin du fichier, ajoutez la commande de Grace comme test :

    tests/test_cli.py (new test)
    def test_web_form_export_has_one_line_per_team(tmp_path):
    output = tmp_path / "week.json"
    assert main(["data/web-form-export.csv", "--output", str(output)]) == 0
    summary = json.loads(output.read_text(encoding="utf-8"))
    expected = {"account": 1, "billing": 3, "login": 4, "shipping": 2}
    assert summary["by_category"] == expected

    Laissez deux lignes vides avant ce test. La valeur attendue est celle du courriel de Grace, pas une valeur copiée d’une exécution.

  3. Exécutez les tests sur le code corrigé :

    Fenêtre de terminal
    python -m pytest
    Output (the last line)
    ============================== 39 passed in 0.04s ==============================
  4. Vérifiez les nouveaux tests : exécutez-les sur le code non corrigé.

    Fenêtre de terminal
    git restore --source=HEAD~1 ticket_cleaner/parsing.py
    python -m pytest
    Sortie (extrait)
    FAILED tests/test_cli.py::test_web_form_export_has_one_line_per_team - Assert...
    FAILED tests/test_parsing.py::test_capital_letters_do_not_make_a_new_category
    FAILED tests/test_parsing.py::test_category_is_cleaned_like_the_other_fields[Billing -billing]
    FAILED tests/test_parsing.py::test_category_is_cleaned_like_the_other_fields[LOGIN-login]
    ========================= 4 failed, 35 passed in 0.05s =========================

    Quatre nouveaux cas échouent sur le code non corrigé. [ SIGN-IN-login] réussit, comme prévu : il protège le comportement existant.

  5. Rétablissez le code corrigé. Ne sautez pas cette étape :

    Fenêtre de terminal
    git restore ticket_cleaner/parsing.py
    python -m pytest

    Les tests donnent à nouveau 39 passed (39 tests réussis).

  6. Vérifiez, puis créez un commit avec les deux fichiers de test :

    Fenêtre de terminal
    ruff check .
    ruff format --check .
    git diff --stat
    git add tests/test_parsing.py tests/test_cli.py
    git commit -m "Test the category cleaning and Grace's export"
    Sortie
    All checks passed!
    21 files already formatted
    tests/test_cli.py | 8 ++++++++
    tests/test_parsing.py | 9 +++++++++
    2 files changed, 17 insertions(+)
    [feature/category-option 2489c76] Test the category cleaning and Grace's export
    2 files changed, 17 insertions(+)

    L’empreinte de votre commit sera différente.

Le diagramme présente chaque nouveau test et son résultat sur les deux versions :

Un tableau des nouveaux tests du module, exécutés sur le code non corrigé, obtenu avec git restore --source=HEAD~1, et sur le code corrigé. test_capital_letters_do_not_make_a_new_category, l'entrée minimale de Grace : échec, puis réussite. Le cas limite Billing avec un espace : échec, puis réussite. Le cas limite LOGIN : échec, puis réussite. Le cas limite SIGN-IN avec un espace, un nom de formulaire Web qui fonctionnait avant : réussite et réussite, il préserve le comportement existant. test_web_form_export_has_one_line_per_team, la commande et le fichier de Grace par main : échec, puis réussite. Les 34 tests précédents, avec test_baseline.py : réussite et réussite. En bas : non corrigé, 4 échecs, 35 réussites; corrigé, 39 réussites.
Chaque nouveau test a été exécuté sur les deux versions. Quatre détectent le bogue; un protège le comportement existant; les anciens tests montrent que rien d'autre n'a changé.
Description textuelle du diagramme

Le diagramme est un tableau des nouveaux tests du module, exécutés sur le code non corrigé (git restore --source=HEAD~1 ticket_cleaner/parsing.py) et sur le code corrigé.

  1. test_capital_letters_do_not_make_a_new_category, l’entrée minimale de Grace : échec sur le code non corrigé, réussite sur le code corrigé.
  2. test_category_is_cleaned_like_the_other_fields[Billing -billing], une majuscule et un espace : échec, puis réussite.
  3. [LOGIN-login], des majuscules : échec, puis réussite.
  4. [ SIGN-IN-login], un nom de formulaire Web en majuscules avec un espace, qui fonctionnait avant : réussite et réussite. Il préserve le comportement existant.
  5. test_web_form_export_has_one_line_per_team, la commande et le fichier de Grace par main() : échec, puis réussite.
  6. Les 34 tests précédents, avec test_baseline.py (le rapport du fichier d’exemple) : réussite et réussite.

En bas : non corrigé, 4 failed, 35 passed (4 échecs, 35 réussites); corrigé, 39 passed.

Les anciens tests comptent aussi. test_baseline.py fixe le rapport du fichier d’exemple du cours Python, présenté dans Préparer le dépôt. Il réussit sur les deux versions : la correction n’a donc rien changé qu’elle ne devait pas changer.

Pour chaque bogue, écrivez le test de régression à partir de l’entrée minimale, avant la correction. Ajoutez les cas limites suggérés par le rapport de bogue et un test de l’exigence par le point d’entrée du programme. Ici, cela représentait 5 cas de test, écrits en quelques minutes. Toute la suite s’exécute encore en un dixième de seconde.

Un assistant peut écrire des tests, et leur coût est faible : la séance miroir a coûté 0,012 $ US en un appel, et la séance avec échec initial, 0,010 $ US. Les prix changent; avec une offre gratuite ou sans assistant, vous ne payez rien. Le prix n’est pas le risque. Le risque est une requête sans l’exigence : le code devient alors la seule source des valeurs attendues. Donnez l’exigence à l’assistant et demandez des tests qui échouent sur le code actuel. Exécutez vous-même chaque nouveau test sur les deux versions.

Ne gardez pas tous les tests qui réussissent. Un test qui fixe un détail inutilisé, comme clean_category(None), complique chaque changement futur et ne protège personne. Testez les comportements dont quelqu’un dépend : le rapport, les catégories, le point d’entrée.

Erreur courante

Le code non corrigé entre dans le commit

Symptôme : Tomás vérifie ses nouveaux tests sur le code non corrigé, comme à l’étape 7. Ils échouent comme prévu, alors il crée un commit avec git add -A. Ensuite, python -m pytest sur la branche donne 4 failed, 35 passed, et le rapport de Grace est encore divisé.

Cause : il a sauté l’étape 8. git restore --source=HEAD~1 a changé parsing.py dans son dossier, et git add -A a inclus ce changement aussi. Avant le commit, les signes étaient visibles :

$ git status --short
M tests/test_cli.py
M tests/test_parsing.py
M ticket_cleaner/parsing.py
$ git diff --stat
tests/test_cli.py | 8 ++++++++
tests/test_parsing.py | 9 +++++++++
ticket_cleaner/parsing.py | 9 +++------
3 files changed, 20 insertions(+), 6 deletions(-)

La leçon ne change que les tests, mais parsing.py figure dans la liste.

Correction : avant le commit, exécutez git restore ticket_cleaner/parsing.py. Après un commit, rétablissez le fichier corrigé depuis le commit de correction avec git restore --source=HEAD~1 ticket_cleaner/parsing.py, puis créez un commit. Ajoutez les fichiers par leur nom et lisez d’abord git diff --stat.

Exercice du module : corriger un défaut et prouver l’efficacité du test

Section intitulée « Exercice du module : corriger un défaut et prouver l’efficacité du test »

L’exercice du module : corriger un défaut introduit et ajouter un test qui détecte la version non corrigée. Vous travaillez dans ticket-cleaner-check, la copie de end-of-m03 créée dans Reproduire d’abord, qui contient encore le bogue de Grace. Vous ciblez le deuxième symptôme : --category login trouve 2 des 4 billets de connexion dans l’exportation de Grace.

  1. Allez dans la copie, activez son environnement et créez un dépôt Git pour pouvoir mettre les modifications de côté :

    Fenêtre de terminal
    cd ~/projects/ticket-cleaner-check
    source .venv/bin/activate
    git init -q && git add -A && git commit -qm "Start"
  2. Par vous-même : écrivez un test dans tests/test_cli.py pour le deuxième symptôme. Tirez ses valeurs attendues de l’exigence, pas d’une exécution. Exécutez-le : il doit échouer.

  3. Par vous-même : corrigez la cause dans ticket_cleaner/parsing.py, sans copier le code de votre projet. Exécutez tous les tests.

  4. Prouvez l’efficacité de votre test avec git stash push ticket_cleaner/parsing.py, exécutez-le, puis lancez git stash pop.

Vérification de fin d’exercice : montrez que votre correction règle la cause et préserve le comportement existant. Nommez les preuves pour chacun.

Afficher une solution détaillée

Le test, à la fin de tests/test_cli.py. Les valeurs attendues viennent de l’exportation de Grace : quatre billets de connexion, tous ouverts.

tests/test_cli.py (new test)
def test_category_option_finds_every_spelling_of_the_team(tmp_path):
output = tmp_path / "login.json"
argv = ["data/web-form-export.csv", "--category", "login"]
assert main([*argv, "--output", str(output)]) == 0
summary = json.loads(output.read_text(encoding="utf-8"))
assert summary["selected"] == 4
assert summary["by_category"] == {"login": 4}

Sur le code non corrigé, l’exécution de l’équipe du cours donne :

python -m pytest tests/test_cli.py
E assert 2 == 4
FAILED tests/test_cli.py::test_category_option_finds_every_spelling_of_the_team
========================= 1 failed, 4 passed in 0.04s ==========================

La correction, dans clean_category() : deux lignes.

text = str(value).strip()
return CATEGORY_ALIASES.get(text.lower(), text)
text = clean_text(value)
return CATEGORY_ALIASES.get(text, text)

Ensuite, python -m pytest donne 35 passed (35 tests réussis). Avec la correction mise de côté, python -m pytest tests/test_cli.py donne encore 1 failed, 4 passed (1 test échoué, 4 réussis); après git stash pop, le test réussit.

Elle règle la cause. Le test échoue sans la correction et réussit avec elle. La correction se trouve dans clean_category(), où les majuscules restaient. Elle ne touche pas le code de --category, qui était correct : il comparait avec le mauvais texte. Une correction dans cli.py ou report.py pourrait faire réussir ce test sans régler le premier symptôme de Grace.

Elle préserve le comportement existant. Les 34 anciens tests réussissent encore, dont test_baseline.py (le rapport du fichier exemple) et le test des noms du formulaire Web. ruff format --check . affiche 21 files already formatted (21 fichiers déjà formatés).

Après avoir comparé votre travail avec la solution, supprimez la copie. Vérifiez le nom du dossier avant d’appuyer sur Entrée :

Fenêtre de terminal
deactivate
cd ~/projects
rm -rf ticket-cleaner-check

Vous avez terminé le module quand vous pouvez montrer ces résultats dans votre propre projet, ~/projects/ticket-cleaner-assist :

  • git log --oneline montre dix commits (enregistrements des modifications) sur feature/category-option. Les deux derniers sont Test the category cleaning and Grace's export (tester le nettoyage des catégories et l’exportation de Grace) et Clean the category like the other fields (Grace's bug) (nettoyer la catégorie comme les autres champs, pour le bogue de Grace).

  • python -m pytest affiche 39 passed (39 tests réussis), et ruff format --check . affiche 21 files already formatted.

  • python -m ticket_cleaner data/web-form-export.csv donne "by_category": {"account": 1, "billing": 3, "login": 4, "shipping": 2}.

  • Les nouveaux tests détectent le code non corrigé. La correction se trouve maintenant deux commits en arrière. main contient encore le point de départ du cours, avec parsing.py non corrigé. Prenez donc le fichier de cette branche. Cela fonctionne aussi après une réinitialisation :

    Fenêtre de terminal
    git restore --source=main ticket_cleaner/parsing.py
    python -m pytest
    git restore ticket_cleaner/parsing.py

    Le premier pytest affiche 4 failed, 35 passed (4 tests échoués, 35 réussis). Après la dernière commande, git status --short n’affiche rien, et les tests donnent 39 passed.

  • Sur macOS et Linux, cette commande n’affiche rien, car votre projet correspond à l’instantané end-of-m04 :

    Fenêtre de terminal
    diff -rq . ../nextia-learning-labs/C15/snapshots/end-of-m04 -x .git -x .venv -x reports -x __pycache__ -x .pytest_cache -x .ruff_cache

Réinitialisation. Si votre projet ne fonctionne plus, suivez les étapes de réinitialisation de Contexte et limites. Utilisez l’instantané end-of-m04 à la place de end-of-m01. La dernière ligne de python -m pytest est alors 39 passed.

Vérifiez votre compréhension

La session « Write tests for clean_category » (écrire des tests pour clean_category) a produit 11 cas de test. Ils ont tous réussi sur le code bogué. Expliquez en deux phrases pourquoi aucun n'a détecté le bogue.

Afficher la réponse

L’assistant a tiré chaque valeur attendue du résultat du code. Il a lu clean_category() et écrit des tests qui disent « faites cela », y compris « préserver les noms de catégories non reconnus ». Un test dont la valeur attendue vient du code testé ne peut que confirmer ce code. Les tests ont donc réussi malgré le bogue, et deux d’entre eux ont échoué après la correction.

Vérifiez votre compréhension

Prédisez les résultats sur le code non corrigé et corrigé pour chaque cas, et dites s'il faut le conserver : (a) clean_category('Invoice') → 'billing'; (b) clean_category(' Custom Category ') → 'Custom Category'; (c) les deux lignes login et LOGIN → ['login', 'login'].

Afficher la réponse
  • (a) Réussit sur les deux : Invoice est un nom du formulaire Web, et cette partie fonctionnait déjà. Conservez-le si aucun autre test ne couvre les noms du formulaire Web. Il protège l’ancien comportement, mais ne prouve pas l’efficacité de la correction.
  • (b) Réussit sur le code non corrigé, échoue sur le code corrigé : il répète le bogue. Supprimez-le, ou corrigez la valeur attendue selon l’exigence pour obtenir 'custom category'.
  • (c) Échoue sur le code non corrigé, réussit sur le code corrigé : il détecte le bogue. Conservez-le : c’est le test de régression.

Vérifiez votre compréhension

Exercice pratique : comment prouver qu'un nouveau test détecte le bogue quand la correction est déjà enregistrée dans un commit? Donnez les commandes pour ce projet et la sortie qui le prouve.

Afficher la réponse

Remettez le fichier non corrigé à partir du commit précédant la correction, exécutez les tests, puis restaurez le fichier corrigé :

Fenêtre de terminal
git restore --source=main ticket_cleaner/parsing.py
python -m pytest
git restore ticket_cleaner/parsing.py

main contient le point de départ du cours, donc son fichier parsing.py est la version non corrigée. HEAD~1 fonctionne aussi, mais seulement quand la correction est le dernier commit. La preuve : les nouveaux tests apparaissent sous FAILED (échoué) sur le code non corrigé (ici 4 failed, 35 passed). Ils réussissent après la restauration (39 passed). Avant d’enregistrer quoi que ce soit dans un commit, git status --short ne doit pas lister parsing.py.

Récapitulatif

Cette leçon

  • Un test est utile quand sa valeur attendue vient de l’exigence. Un test miroir la tire du code testé et ne peut que confirmer ce code.
  • « Write tests for clean_category » a donné 11 cas : aucun n’a détecté le bogue, et 2 ont échoué après la correction. Une requête (prompt) contenant l’exigence et demandant un test qui échoue d’abord a donné 1 cas qui l’a détecté.
  • Pour un bogue : un test de régression, des cas limites et l’exigence vérifiée par le point d’entrée. Prouvez l’efficacité de chaque nouveau test sur le code non corrigé et corrigé.
  • Votre projet correspond à end-of-m04 : 39 passed.

Module 4 : déboguer et tester avec l’assistant

  • Reproduire d’abord : une entrée minimale qui échoue et un environnement neuf pour distinguer un défaut du code d’un problème d’environnement.
  • Demander des preuves : une hypothèse, une vérification ciblée, un test qui échoue, et seulement ensuite la correction. Dans les exécutions de l’équipe du cours, les corrections à l’aveugle fonctionnaient, mais ne laissaient aucune preuve.
  • Choisir des vérifications utiles : des valeurs attendues tirées de l’exigence et chaque nouveau test vérifié sur les deux versions.

Ensuite, dans le module 5, vous préparez le projet pour le remettre à quelqu’un d’autre. Vous améliorez le code seulement là où le changement l’exige, et vous notez vos décisions.

Leçon suivante : Réusiner de façon sélective