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.
Leçon 12 sur 15 · Développement logiciel assisté par l'IAChoisir des vérifications utiles
1. Mettre en place un environnement de travail sûr
2. Rédiger des tâches exploitables
3. Réviser le travail généré
4. Déboguer et tester avec l'assistant
5. Livrer un travail facile à maintenir
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 main
Ce que vous devez savoir
- Le test de régression et
git stash, dans Demander des preuves. - Les cas normaux, limites et d’erreur, dans Des tests ciblés du cours Python.
HEAD~1, « un commit avant HEAD », dans Annuler en toute sécurité du cours Git.
Ce qu’il vous faut sur votre ordinateur
- Le projet
~/projects/ticket-cleaner-assistavec la correction dans un commit :35 passed(35 tests réussis),git statussans changements, l’environnement actif. - La copie
~/projects/ticket-cleaner-checkde 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.
Un corrigé copié sur la copie d’un élève
Section intitulée « Un corrigé copié sur la copie d’un élève »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.
Le problème : des tests qui approuvent le bogue
Section intitulée « Le problème : des tests qui approuvent le bogue »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) :
Write tests for clean_category in ticket_cleaner/parsing.py.I'll add direct tests for alias normalization, whitespace trimming, preserving unrecognized category names, and converting non-string inputs to text. Noproduction 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 :
(" 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 :
- 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é.
- 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.
- 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 :
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() :
python -c "from ticket_cleaner.parsing import split_records; print(split_records([{'id': 'T-1', 'status': 'open', 'category': None, 'priority': '1'}])[1])"[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é.
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.
- Le code testé, ce qu’il renvoie aujourd’hui. Exemples :
clean_category(' Custom Category ')→'Custom Category', etclean_category(None)→'None'. Non corrigé : réussite; corrigé : échec. Le test répète le bogue : il échoue quand le bogue est corrigé. - Une partie du code qui fonctionne déjà. Exemples :
clean_category('Sign-in')→'login', etclean_category(' billing ')→'billing'. Réussite sur les deux. Le test préserve le comportement existant, mais ne peut pas révéler ce bogue. - 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?
Prédisez d’abord : Douze cas de test, tous écrits par un assistant. Combien échouent sur le code non corrigé et réussissent sur le code corrigé?
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.
| Cas de test et valeur attendue | Consigne | Code non corrigé | Code corrigé | Verdict |
|---|---|---|---|---|
clean_category('Sign-in')→ 'login'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category('log-in')→ 'login'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category(' sign-in ')→ 'login'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category(' LOG-IN ')→ 'login'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category('billing')→ 'billing'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category(' billing ')→ 'billing'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | ré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éussi | réussi | réussit sur les deux |
clean_category(' \t\n ')→ ''« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | réussit sur les deux |
clean_category(123)→ '123'« Write tests for clean_category » | « Write tests for clean_category » | réussi | réussi | ré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éussi | détecte le bogue |
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 '→'', et123→'123'. 2 réussissent sur le code non corrigé et échouent sur le code corrigé :' Custom Category '→'Custom Category'etNone→'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.
Observez-le dans votre projet
Section intitulée « Observez-le dans votre projet »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.
-
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.patchgit diff --statpython -m pytestSortie (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.
-
Rétablissez le fichier
parsing.pynon corrigé et exécutez les tests à nouveau :Fenêtre de terminal git restore --source=HEAD~1 ticket_cleaner/parsing.pypython -m pytestpython -m pytest -k clean_categoryOutput (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_categorysélectionne les 11 cas de la séance dont les noms contiennentclean_category: les 11 réussissent. Aucun ne détecte le bogue. -
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.pygit status --shortpython -m pytestgit status --shortn’affiche rien, et les tests donnent35 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.
-
Ouvrez
tests/test_parsing.py. Aprèstest_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"] = nameassert to_ticket(valid_raw).category == expectedChaque 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. -
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)]) == 0summary = json.loads(output.read_text(encoding="utf-8"))expected = {"account": 1, "billing": 3, "login": 4, "shipping": 2}assert summary["by_category"] == expectedLaissez deux lignes vides avant ce test. La valeur attendue est celle du courriel de Grace, pas une valeur copiée d’une exécution.
-
Exécutez les tests sur le code corrigé :
Fenêtre de terminal python -m pytestOutput (the last line) ============================== 39 passed in 0.04s ============================== -
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.pypython -m pytestSortie (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_categoryFAILED 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. -
Rétablissez le code corrigé. Ne sautez pas cette étape :
Fenêtre de terminal git restore ticket_cleaner/parsing.pypython -m pytestLes tests donnent à nouveau
39 passed(39 tests réussis). -
Vérifiez, puis créez un commit avec les deux fichiers de test :
Fenêtre de terminal ruff check .ruff format --check .git diff --statgit add tests/test_parsing.py tests/test_cli.pygit commit -m "Test the category cleaning and Grace's export"Sortie All checks passed!21 files already formattedtests/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 export2 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 :
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é.
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é.test_category_is_cleaned_like_the_other_fields[Billing -billing], une majuscule et un espace : échec, puis réussite.[LOGIN-login], des majuscules : échec, puis réussite.[ 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.test_web_form_export_has_one_line_per_team, la commande et le fichier de Grace parmain(): échec, puis réussite.- 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.
Quand écrire chaque test, et à quel coût
Section intitulée « Quand écrire chaque test, et à quel coût »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.
-
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-checksource .venv/bin/activategit init -q && git add -A && git commit -qm "Start"Fenêtre de terminal cd ~\projects\ticket-cleaner-check.venv\Scripts\Activate.ps1git init -q; git add -A; git commit -qm "Start" -
Par vous-même : écrivez un test dans
tests/test_cli.pypour le deuxième symptôme. Tirez ses valeurs attendues de l’exigence, pas d’une exécution. Exécutez-le : il doit échouer. -
Par vous-même : corrigez la cause dans
ticket_cleaner/parsing.py, sans copier le code de votre projet. Exécutez tous les tests. -
Prouvez l’efficacité de votre test avec
git stash push ticket_cleaner/parsing.py, exécutez-le, puis lancezgit 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.
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 :
E assert 2 == 4FAILED 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 :
deactivatecd ~/projectsrm -rf ticket-cleaner-checkdeactivatecd ~\projectsRemove-Item -Recurse -Force ticket-cleaner-checkVérification du module
Section intitulée « Vérification du module »Vous avez terminé le module quand vous pouvez montrer ces résultats dans votre propre projet, ~/projects/ticket-cleaner-assist :
-
git log --onelinemontre dix commits (enregistrements des modifications) surfeature/category-option. Les deux derniers sontTest the category cleaning and Grace's export(tester le nettoyage des catégories et l’exportation de Grace) etClean the category like the other fields (Grace's bug)(nettoyer la catégorie comme les autres champs, pour le bogue de Grace). -
python -m pytestaffiche39 passed(39 tests réussis), etruff format --check .affiche21 files already formatted. -
python -m ticket_cleaner data/web-form-export.csvdonne"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.
maincontient encore le point de départ du cours, avecparsing.pynon 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.pypython -m pytestgit restore ticket_cleaner/parsing.pyLe premier
pytestaffiche4 failed, 35 passed(4 tests échoués, 35 réussis). Après la dernière commande,git status --shortn’affiche rien, et les tests donnent39 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érification des connaissances
Section intitulée « Vérification des connaissances »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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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 :
Invoiceest 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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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é :
git restore --source=main ticket_cleaner/parsing.pypython -m pytestgit restore ticket_cleaner/parsing.pymain 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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
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