Aller au contenu
English

Demander des preuves

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

Où nous en sommes

Dans la dernière leçon, nous avons reproduit le bogue de Grace avec une entrée minimale et montré que la cause est dans le code. Maintenant, nous cherchons la cause. Si nous disons seulement « Corrigez ça. », une correction peut fonctionner, mais elle ne laisse aucune preuve de la raison. Dans cette leçon, nous demandons une hypothèse et une vérification qui peut la réfuter, puis un test qui échoue, et seulement ensuite la correction, comme une médecin qui appuie là où elle pense que ça fait mal.

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

Ce que vous saurez faire

Trouvez la cause d’un bogue avec une hypothèse et une vérification qui peut la réfuter. Demandez la même chose à un assistant. Chaque correction s’accompagne alors d’une preuve : un test qui échouait avant la correction et réussit après.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet ~/projects/ticket-cleaner-assist : 34 passed (34 tests réussis), aucun changement dans git status, l’environnement actif.
  • Facultatif : un assistant de programmation. Sans assistant, vous lisez les sessions enregistrées et vous faites chaque étape vous-même.

Vous dites à un médecin : « Mon genou fait mal quand je monte les escaliers. » Un médecin répond : « Prenez ces comprimés. Si la douleur persiste, revenez. » Vous revenez deux fois et recevez des comprimés différents chaque fois. Les troisièmes fonctionnent peut-être. Vous ne savez jamais pourquoi.

Une autre médecin dit : « Je pense que c’est le tendon sous la rotule. Si j’ai raison, vous aurez mal quand j’appuie ici. » Elle appuie. Ça fait mal. Le traitement a maintenant une raison. Plus tard, elle appuie de nouveau au même endroit. Ça ne fait plus mal. Vous savez tous les deux que le traitement a fonctionné.

Si la pression n’avait pas fait mal, elle n’aurait pas donné ce traitement malgré tout. Elle aurait envisagé une autre cause et l’aurait vérifiée.

Le problème : « Corrigez ça. » encore et encore

Section intitulée « Le problème : « Corrigez ça. » encore et encore »

L’équipe du cours a donné deux fichiers à un assistant, report.py et cli.py, sans carte du dépôt. Elle a fourni une seule requête (prompt) (transcription bug-fix-blind-no-map) :

Prompt, turn 1
Grace says the report is wrong for the new web form export. Fix it.

L’assistant a demandé des preuves au lieu de modifier quoi que ce soit :

What the assistant printed (part)
What is wrong with the report for the new web form export? Please share:
- A small sample export that reproduces the issue (with sensitive data removed).
- The command used to generate the report.
- The actual report and the expected result.

Les deux requêtes suivantes n’apportaient rien de nouveau : « C’est encore incorrect. Corrigez ça. » Au deuxième échange, il a redemandé des preuves, ainsi que trois autres fichiers. L’outil les a ajoutés. Le modèle a nommé une cause probable dans clean_category(), mais a demandé un exemple pour la confirmer. Au troisième échange, il a demandé encore une fois, puis a modifié le code :

What the assistant printed in turn 3 (part)
Also provide a small anonymized export, the command you ran, and the actual versus expected report. The earlier suggestion about category capitalization was
unverified.

Sa modification était correcte : les 5 vérifications cachées du bogue faites par l’équipe du cours ont réussi. Mais regardez ce que la session vous laisse. Elle a pris 3 échanges et 5 appels au modèle. Elle n’a exécuté aucun exemple. Elle n’a ajouté aucun test, donc 24 passed (24 tests réussis) avant comme après. L’assistant a lui-même dit que son idée était « non vérifiée ». Un résultat correct dont personne ne peut démontrer la justesse est un résultat obtenu par chance.

Cette leçon ne peut donc pas vous dire que les réécritures à l’aveugle échouent. Dans les essais de l’équipe du cours, elles n’ont pas échoué. Elle montre autre chose : une correction à l’aveugle ne laisse aucune preuve. Le diagramme compare quatre sessions enregistrées du même bogue :

Un tableau de quatre sessions enregistrées du bogue de Grace. Corrigez ça, grand modèle, carte du dépôt activée : 6 fichiers demandés, 3 fichiers modifiés, plus 44 moins 3, en un échange, 31 tests réussis, 2 appels, 0,026 $ US; preuves : 7 nouveaux cas de test, 5 détectent le bogue, 2 réussissent sur les deux versions, aucun test n'a échoué avant la correction. Corrigez ça, petit modèle : 2 fichiers demandés, une ligne modifiée, 24 tests réussis, 2 appels, 0,0019 $ US; preuves : aucun nouveau test. Corrigez ça, puis deux fois C'est encore incorrect, sans carte : aux échanges 1 et 2, demande d'un exemple et de fichiers; à l'échange 3, modification de 3 lignes, 24 tests réussis, 5 appels, 0,040 $ US; preuves : aucun test, aucun exemple exécuté, l'assistant a qualifié son idée précédente de non vérifiée. Les preuves d'abord : échange 1, une hypothèse avec la ligne; échange 2, le test, 1 échec et 24 réussites; échange 3, une ligne modifiée, 25 tests réussis, 3 appels, 0,028 $ US; preuves : un test qui échouait avant la correction et réussit après. En bas : un résultat correct n'est pas encore une preuve; un test qui échoue d'abord en est une.
Les quatre sessions ont corrigé le bogue. Une seule montre pourquoi, avec un test qui a d'abord échoué.
Description textuelle du diagramme

Le diagramme est un tableau de quatre sessions enregistrées du bogue de Grace. Les quatre ont fini par réussir les 5 vérifications cachées du bogue.

  1. « Corrigez ça. », grand modèle, carte du dépôt activée. Il a demandé 6 fichiers, les a reçus et a modifié 3 fichiers (+44 −3) en un échange : 31 passed (31 tests réussis), 2 appels, 0,026 $ US. Preuves : 7 nouveaux cas de test, dont 5 détectent le bogue et 2 réussissent sur les deux versions. Aucun test n’a échoué avant la correction. Vous devez donc vérifier cela vous-même.
  2. « Corrigez ça. », petit modèle. Il a demandé 2 fichiers, les a reçus et a modifié une ligne (+1 −1) : 24 passed, 2 appels, 0,0019 $ US. Preuves : aucun nouveau test. Si le bogue revient, aucun test n’échoue.
  3. « Corrigez ça. », puis deux fois « C’est encore incorrect. Corrigez ça. », sans carte du dépôt. Aux échanges 1 et 2, il a demandé un exemple et des fichiers; à l’échange 3, il a modifié 3 lignes : 24 passed, 5 appels, 0,040 $ US. Preuves : aucun test et aucun exemple exécuté. Au troisième échange, il a dit que son idée précédente était « non vérifiée », puis a modifié le code.
  4. Les preuves d’abord : une hypothèse, un test qui échoue, puis la correction. Échange 1 : une hypothèse avec la ligne, aucune modification. Échange 2 : le test, 1 failed, 24 passed (1 échec, 24 réussites). Échange 3 : une ligne modifiée, 25 passed (25 tests réussis). 3 appels, 0,028 $ US. Preuves : un test qui échouait avant la correction et réussit après.

En bas : un résultat correct n’est pas encore une preuve. Un test qui échoue d’abord en est une.

L’idée : une hypothèse et une vérification ciblée

Section intitulée « L’idée : une hypothèse et une vérification ciblée »

Une hypothèse est une supposition sur la cause, assez précise pour être testée. Elle nomme un endroit dans le code et prédit ce qu’une vérification montrera. « Quelque chose ne va pas avec les catégories » n’est pas une hypothèse : aucun résultat ne peut la réfuter. « clean_category() renvoie le texte d’origine quand le nom n’est pas un nom du formulaire Web » en est une. Elle prédit que clean_category("LOGIN") renvoie "LOGIN".

Une vérification ciblée est la plus petite exécution qui peut réfuter l’hypothèse : un appel de fonction, une commande, un test. Elle est ciblée parce qu’elle examine un seul endroit, pas le programme entier. Si le résultat contredit la prédiction, l’hypothèse est fausse et vous en avez besoin d’une nouvelle. S’il la confirme, vous avez une preuve : une sortie que vous pouvez montrer à quelqu’un d’autre.

Organisez les étapes en boucle, et vous obtenez la méthode de la médecin appliquée au code :

Une boucle de six étapes. 1 Observation : le rapport de Grace contient Billing, LOGIN et Login à côté de billing et login. 2 Entrée minimale : 2 lignes, login et LOGIN, donnent LOGIN 1 et login 1, pareil dans un nouvel environnement. 3 Hypothèse : clean_category garde le texte d'origine quand le nom n'est pas un nom du formulaire Web. 4 Vérification ciblée : clean_category de LOGIN renvoie LOGIN; le test à deux lignes donne 1 échec et 34 réussites. Une flèche revient de l'étape 4 à l'étape 3 : la vérification contredit l'hypothèse, il faut une nouvelle hypothèse. 5 Correction : text égale clean_text de value, une seule règle de nettoyage, comme pour le statut et l'identifiant. 6 Test de non-régression, en vert : 35 tests réussis; l'exportation de Grace donne account 1, billing 3, login 4, shipping 2; sans la correction, le test échoue de nouveau. Une flèche rouge en pointillés, étiquetée Corrigez ça, va directement de l'étape 1 à l'étape 5. À côté de la boucle, quatre sessions mesurées : Corrigez ça avec le grand modèle, 1 échange, 3 fichiers, plus 44 moins 3, 5 vérifications sur 5, aucun test n'a échoué avant la correction; Corrigez ça avec le petit modèle, plus 1 moins 1, aucun nouveau test; Corrigez ça trois fois sans carte, échanges 1 et 2 demande de preuves, échange 3 plus 3 moins 3, aucun test; les preuves d'abord, 1 échec et 24 réussites, puis une ligne modifiée, 25 tests réussis, 5 vérifications sur 5.
La boucle de débogage : chaque étape produit les preuves utilisées par l'étape suivante. « Corrigez ça. » passe directement de l'observation à une correction et saute les preuves.
Description textuelle du diagramme

Le diagramme est une boucle de six étapes. Chacune utilise le bogue de Grace comme exemple.

  1. Observation : le rapport de Grace contient Billing, LOGIN et Login à côté de billing et login.
  2. Entrée minimale : deux lignes, login et LOGIN, donnent {"LOGIN": 1, "login": 1}, pareil dans un nouvel environnement.
  3. Hypothèse : clean_category() garde le texte d’origine quand le nom n’est pas un nom du formulaire Web.
  4. Vérification ciblée : clean_category('LOGIN') renvoie 'LOGIN'; le test à deux lignes donne 1 failed, 34 passed (1 échec, 34 réussites). Une flèche revient de l’étape 4 à l’étape 3 : si la vérification contredit l’hypothèse, il vous en faut une nouvelle.
  5. Correction : text = clean_text(value), une seule règle de nettoyage, comme pour le statut et l’identifiant.
  6. Test de non-régression, en vert : 35 passed (35 tests réussis); l’exportation de Grace donne account 1, billing 3, login 4, shipping 2; sans la correction, le test échoue de nouveau.

Une flèche rouge en pointillés, étiquetée « Corrigez ça. », va directement de l’étape 1 à l’étape 5.

À côté de la boucle se trouvent les quatre sessions mesurées du tableau précédent :

  • « Corrigez ça. » avec le grand modèle : 1 échange, 3 fichiers, +44 −3, 5 vérifications sur 5, aucun test n’a échoué avant la correction.
  • « Corrigez ça. » avec le petit modèle : +1 −1, aucun nouveau test.
  • « Corrigez ça. » trois fois sans carte : aux échanges 1 et 2, demande de preuves; à l’échange 3, modification de 3 lignes, aucun test.
  • Les preuves d’abord : 1 failed, 24 passed, puis une ligne modifiée, 25 passed, 5 vérifications sur 5.

Les quatre ont réussi les 5 vérifications de Grace. Une seule a laissé un test qui a d’abord échoué.

Vous avez déjà fait les étapes 1 et 2 dans Reproduire d’abord. Cette leçon couvre les étapes 3 à 6.

Lisez la fonction dans ticket_cleaner/parsing.py :

ticket_cleaner/parsing.py (lines 18 to 21)
def clean_category(value: object) -> str:
"""Return the category, with the web form's names changed to the report's names."""
text = str(value).strip()
return CATEGORY_ALIASES.get(text.lower(), text)

CATEGORY_ALIASES.get(key, default) cherche la clé parmi les noms du formulaire Web. Si la clé s’y trouve, elle renvoie le nom utilisé dans le rapport. Sinon, elle renvoie la valeur par défaut : text, l’orthographe d’origine. L’hypothèse prédit trois résultats : LOGIN reste LOGIN, Sign-in devient login et login devient login. Une commande vérifie les trois :

Fenêtre de terminal
python -c "from ticket_cleaner.parsing import clean_category; print(repr(clean_category('LOGIN')), repr(clean_category('Sign-in')), repr(clean_category(' login ')))"
Sortie
'LOGIN' 'login' 'login'

Les trois résultats confirment la prédiction. La vérification a pris une seconde et a examiné une fonction, pas le programme entier.

Testez aussi une hypothèse concurrente : « report.py compte mal ». Si c’était vrai, deux billets de même catégorie pourraient quand même donner deux lignes. Donnez deux billets login à count_by_category() :

Fenêtre de terminal
python -c "from ticket_cleaner.records import Ticket; from ticket_cleaner.report import count_by_category; t = [Ticket('T-1', 'open', 'login', 1), Ticket('T-2', 'open', 'login', 1)]; print(count_by_category(t))"
Sortie
{'login': 2}

Le compte est correct, donc l’hypothèse concurrente est fausse. La cause se trouve plus tôt, dans le texte reçu par la fonction de comptage.

Vous pouvez demander à un assistant de suivre la même boucle. L’équipe du cours l’a enregistrée (transcription bug-fix-evidence), avec le même modèle que pour les sessions à l’aveugle. La première requête contenait le courriel de Grace et l’entrée à deux lignes, comme dans Fournir le contexte utile. Elle se terminait par une demande d’hypothèse, pas de correction :

Prompt, turn 1 (the end; the assistant may not change files)
Do not change any file yet. Give one hypothesis for the cause, with the line of code, and say which small test would show that the hypothesis is right.
What the assistant printed (part)
**Hypothesis:** `clean_category()` preserves the original casing for categories that are not aliases:
```python
return CATEGORY_ALIASES.get(text.lower(), text)
```
The lookup uses lowercase, but its fallback is `text`. Since `"LOGIN"` is not an alias key, it stays `"LOGIN"` instead of becoming `"login"`, splitting the
report counts.

Il a nommé la ligne et proposé un test de trois lignes. Il a aussi écrit : « Avec le code actuel, il échoue ». Mais il n’avait rien exécuté. Cette phrase est une prédiction. La requête suivante la vérifie donc :

Prompt, turn 2
Add that test to tests/test_parsing.py and nothing else. It must fail on the current code.

Après le deuxième échange, les tests du projet ont donné 1 failed, 24 passed : la prédiction était correcte. La dernière requête a demandé la modification seulement après cela :

Prompt, turn 3 (the assistant runs the tests after its edit)
Now fix the cause with the smallest change, so that all the tests pass.
What the assistant printed (part)
Lowercase the fallback category so non-alias names merge regardless of casing. Alias handling stays unchanged.
(...)
25 passed in 0.03s

Sa modification tenait en une ligne : text est devenu text.lower() dans la valeur par défaut de CATEGORY_ALIASES.get(). La session a pris 3 appels et coûté 0,028 $ US. Chaque échange a produit une preuve : une hypothèse avec sa ligne, un test qui a échoué, puis une correction qui l’a fait réussir.

Les trois requêtes fonctionnent avec n’importe quel assistant, même dans une fenêtre de clavardage où vous déplacez le code vous-même :

  1. « Ne modifiez aucun fichier pour l’instant. Donnez une hypothèse, avec la ligne de code, et un petit test qui la vérifierait. »
  2. « Ajoutez ce test et rien d’autre. Il doit échouer avec le code actuel. » Ensuite, exécutez-le vous-même.
  3. « Corrigez maintenant la cause avec la plus petite modification possible, pour que tous les tests réussissent. » Ensuite, exécutez-les vous-même.

Vous allez maintenant suivre la boucle dans votre projet. Si vous utilisez un assistant, envoyez-lui les trois requêtes, avec le rapport de bogue et les fichiers parsing.py, records.py et tests/test_parsing.py. Comparez son hypothèse, son test et sa correction aux étapes ci-dessous. N’acceptez rien avant d’avoir vu le test échouer.

  1. Exécutez la vérification ciblée du petit exemple précédent. Elle affiche 'LOGIN' 'login' 'login'.

  2. Regardez comment les autres champs sont nettoyés :

    Fenêtre de terminal
    grep -n "clean_text(raw" ticket_cleaner/parsing.py
    Output (macOS)
    30: if clean_text(raw.get(field)) == "":
    33: status = clean_text(raw.get("status"))
    37: priority = clean_text(raw.get("priority"))
    46: id=clean_text(raw["id"]).upper(),
    47: status=clean_text(raw["status"]),
    49: priority=int(clean_text(raw["priority"])),

    Chaque champ passe par clean_text(), qui supprime les espaces aux extrémités et convertit le texte en minuscules. Seule la catégorie, à la ligne 48, ne le fait pas. C’est la règle attendue. Le rapport de bogue le dit aussi : « comme pour le statut et l’identifiant ».

  3. Écrivez le test de non-régression à partir de l’entrée minimale. Ouvrez tests/test_parsing.py. Après le test test_web_form_names_become_report_categories, ajoutez :

    tests/test_parsing.py (new test)
    def test_capital_letters_do_not_make_a_new_category():
    # Grace's bug report: "LOGIN" and "login" were counted as two categories.
    rows = [
    {"id": "T-1", "status": "open", "category": "login", "priority": "1"},
    {"id": "T-2", "status": "open", "category": "LOGIN", "priority": "1"},
    ]
    tickets, rejected = split_records(rows)
    assert rejected == []
    assert [ticket.category for ticket in tickets] == ["login", "login"]

    Laissez deux lignes vides avant le test suivant. Le test utilise les deux lignes du rapport de bogue et la valeur attendue dans ce rapport.

  4. Exécutez les tests. Le nouveau test doit échouer pour la raison prédite par l’hypothèse :

    Fenêtre de terminal
    python -m pytest
    Output (the end)
    > assert [ticket.category for ticket in tickets] == ["login", "login"]
    E AssertionError: assert ['login', 'LOGIN'] == ['login', 'login']
    E
    E At index 1 diff: 'LOGIN' != 'login'
    E Use -v to get more diff
    tests/test_parsing.py:37: AssertionError
    =========================== short test summary info ============================
    FAILED tests/test_parsing.py::test_capital_letters_do_not_make_a_new_category
    ========================= 1 failed, 34 passed in 0.05s =========================

    Le deuxième billet garde 'LOGIN'. C’est la vérification ciblée, maintenant conservée sous forme de test.

  5. Corrigez la cause. Dans ticket_cleaner/parsing.py, remplacez la fonction clean_category() par cette version :

    ticket_cleaner/parsing.py
    def clean_category(value: object) -> str:
    """Return the category as the report names it: cleaned, in small letters.
    The web form's names are changed to the report's names (CATEGORY_ALIASES).
    """
    text = clean_text(value)
    return CATEGORY_ALIASES.get(text, text)

    clean_text() renvoie déjà des minuscules. La recherche n’a donc pas besoin de .lower(). La chaîne de documentation indique maintenant ce que la fonction promet.

  6. Exécutez les tests de nouveau :

    Fenêtre de terminal
    python -m pytest
    Output (the last line)
    ============================== 35 passed in 0.03s ==============================

Pourquoi clean_text(value), et non le text.lower() de la session enregistrée? Les deux réussissent tous les tests et les 5 vérifications cachées. Mais la ligne de la session ajoute une deuxième règle de nettoyage, utilisée seulement pour les catégories. Amira préfère une seule règle pour tous les champs : si l’équipe modifie le nettoyage du texte, elle le fait à un seul endroit. C’est une décision, pas un résultat de test. Elle l’écrit donc dans le message du commit (enregistrement des modifications). Cela explique aussi pourquoi « la correction de l’assistant fonctionne » ne suffit pas pour terminer une révision.

Prouvez maintenant que le test dépend de la correction. Mettez temporairement la correction de côté, et seulement la correction :

  1. Mettez la modification de parsing.py en réserve, exécutez les tests, puis rétablissez la modification :

    Fenêtre de terminal
    git stash push ticket_cleaner/parsing.py
    python -m pytest
    git stash pop
    python -m pytest
    Output (the last lines)
    FAILED tests/test_parsing.py::test_capital_letters_do_not_make_a_new_category
    ========================= 1 failed, 34 passed in 0.06s =========================
    ============================== 35 passed in 0.04s ==============================

    Sans la correction, le test échoue; avec elle, il réussit. C’est la preuve.

  2. Exécutez la commande de Grace et vérifiez le deuxième symptôme de la leçon précédente :

    Fenêtre de terminal
    python -m ticket_cleaner data/web-form-export.csv
    python -m ticket_cleaner data/web-form-export.csv --category login

    Après la première commande, by_category vaut {"account": 1, "billing": 3, "login": 4, "shipping": 2} : le résultat attendu par Grace. Après la deuxième, le rapport contient "selected": 4. Une seule correction a réglé les deux symptômes, comme le suggérait l’entrée minimale commune.

  3. Vérifiez le format et la taille de la modification, puis faites un commit du test et de la correction ensemble :

    Fenêtre de terminal
    ruff check .
    ruff format --check .
    git diff --stat
    git add ticket_cleaner/parsing.py tests/test_parsing.py
    git commit -m "Clean the category like the other fields (Grace's bug)"
    Sortie
    All checks passed!
    21 files already formatted
    tests/test_parsing.py | 11 +++++++++++
    ticket_cleaner/parsing.py | 9 ++++++---
    2 files changed, 17 insertions(+), 3 deletions(-)
    [feature/category-option 211fca5] Clean the category like the other fields (Grace's bug)
    2 files changed, 17 insertions(+), 3 deletions(-)

    L’empreinte de votre commit sera différente.

Demandez des preuves pour chaque bogue signalé par un utilisateur et chaque modification que vous ne pouvez pas vérifier en la lisant. En argent, la différence est petite. La session avec preuves a coûté 0,028 $ US en 3 appels. La session à l’aveugle avec carte a coûté 0,026 $ US en 2 appels. Celle qui répétait « Corrigez ça. » a coûté 0,040 $ US en 5 appels. Les prix changent. Consultez donc la page actuelle de votre fournisseur. Avec une offre gratuite ou sans assistant, vous ne payez rien.

Le vrai coût est votre temps : quelques minutes pour une hypothèse et un test. Vous récupérez ce temps dès qu’une hypothèse est fausse. Sans vérification, une mauvaise supposition devient une mauvaise modification, puis une deuxième modification par-dessus la première.

Il y a des limites. Une hypothèse peut être confirmée par une vérification tout en restant incomplète : la vérification examine un seul endroit. Voilà pourquoi la boucle se termine par tous les tests et la commande de Grace, pas seulement le nouveau test. Pour une expérience que vous ne garderez pas, une supposition rapide convient. Vous n’allez pas la fusionner.

Erreur courante

La mise en réserve prend aussi le test

Symptôme : Tomás veut voir le nouveau test échouer sans la correction. Il exécute git stash, puis python -m pytest :

Saved working directory and index state WIP on feature/category-option: 1c3a803 Start
============================== 34 passed in 0.04s ==============================

Tous les tests réussissent, sans la correction. (Dans votre projet, la ligne de mise en réserve nomme votre dernier commit.) Il conclut que le test n’a pas besoin de la correction.

Cause : git stash sans nom de fichier met toutes les modifications en réserve : la correction et le nouveau test. Le test n’est plus dans le dossier. Il ne peut donc pas échouer. 34 passed correspond à l’ancienne suite de tests. Le nombre le révèle : 34, pas 35.

Correction : git stash pop rétablit les deux modifications; git status --short affiche alors de nouveau les deux fichiers. Mettez seulement la correction en réserve : git stash push ticket_cleaner/parsing.py. Lisez toujours le nombre de tests, pas seulement le mot « passed » (réussis).

À vous de jouer : une hypothèse pour le deuxième symptôme

Section intitulée « À vous de jouer : une hypothèse pour le deuxième symptôme »

Avant votre correction, --category login trouvait 2 des 4 billets de connexion. Écrivez une hypothèse qui l’explique et indiquez l’endroit dans le code. Nommez ensuite une vérification ciblée et dites ce qu’elle a montré après votre correction.

Afficher la réponse

Hypothèse : l’option compare la catégorie de chaque billet au nom nettoyé login. Avant la correction, les billets T-3003 et T-3008 conservaient Login et LOGIN. Ils ne correspondaient donc pas. L’option fonctionnait bien; les catégories qu’elle comparait étaient incorrectes. La cause se trouve à la même ligne de clean_category().

Vérification ciblée : la même commande après la correction. Si l’hypothèse est juste, le rapport contient "selected": 4 et {"login": 4}. L’étape 8 a montré exactement cela. Voici une vérification qui pourrait la réfuter : si l’option faisait elle-même une mauvaise comparaison, elle manquerait encore des billets après la correction.

Ce dont vous n’aviez pas besoin : une modification de report.py ou de cli.py. Une requête à l’aveugle, « corrigez l’option –category », aurait pu modifier l’option sans éliminer la cause.

Vérifiez votre compréhension

Laquelle de ces hypothèses pouvez-vous tester? Pour chacune, dites pourquoi. (a) « Le code des catégories contient un bogue. » (b) « clean_category() renvoie le texte original quand le nom ne vient pas d'un formulaire Web, donc clean_category('LOGIN') renvoie LOGIN. » (c) « L'assistant a probablement fait une erreur. »

Afficher la réponse

Seulement (b). Elle nomme un endroit, clean_category(), et prédit un résultat précis, 'LOGIN'. Une seule commande peut la réfuter. (a) nomme une partie du code, mais ne prédit rien : tous les résultats sont compatibles avec elle. (c) concerne une personne, pas le code, et ne propose aucune vérification à exécuter.

Vérifiez votre compréhension

Dans la séance de recherche de preuves, l'assistant a écrit au premier échange que son test « échoue » sur le code actuel. Pourquoi la requête suivante disait-elle encore « Il doit échouer sur le code actuel »? Que feriez-vous s'il avait réussi?

Afficher la réponse

Au premier échange, l’assistant n’avait rien exécuté. « Il échoue » était une prédiction présentée comme un fait. Le deuxième échange en a fait un résultat : 1 failed, 24 passed (1 test échoué, 24 réussis). Si le test avait réussi, soit il ne testait pas le bogue, soit l’hypothèse était fausse. Dans ce cas, vous ne demandez pas de correction. Vous revenez à l’hypothèse, ou vous écrivez un test qui échoue à partir de l’entrée minimale.

Vérifiez votre compréhension

Prédisez le résultat : vous remisez seulement la correction avec git stash push ticket_cleaner/parsing.py et exécutez python -m pytest. Quelle est la dernière ligne, et pourquoi est-ce la preuve dont vous avez besoin?

Afficher la réponse

1 failed, 34 passed (1 test échoué, 34 réussis), avec FAILED tests/test_parsing.py::test_capital_letters_do_not_make_a_new_category (échec du test indiqué). Le test est toujours dans le dossier, et le code est revenu à la version non corrigée. Le test échoue donc sans la correction et réussit avec elle, après git stash pop. Cela montre que le test détecte le bogue et que la correction le résout.

Récapitulatif

  • Une hypothèse nomme un endroit dans le code et prédit un résultat. Une vérification ciblée est la plus petite exécution capable de la réfuter.
  • La boucle de débogage : observation, entrée minimale, hypothèse, vérification ciblée, correction, test de non-régression. « Corrigez-le. » passe directement de l’observation à la correction.
  • Dans les essais de l’équipe du cours, les corrections à l’aveugle fonctionnaient, mais ne laissaient aucune preuve : aucun test n’échouait d’abord. Demander une hypothèse, puis un test qui échoue, puis la correction fournissait les trois pour environ le même coût.
  • La correction acceptée utilise clean_text(), une seule règle de nettoyage pour tous les champs. Remisez seulement la correction pour voir le test échouer de nouveau.
  • Votre projet contient un nouveau commit (enregistrement des modifications) : la correction et son test de non-régression, 35 passed (35 tests réussis).

Ensuite, Tomás demande à l’assistant d’écrire le reste des tests. Vous découvrez quels tests méritent d’être conservés.

Leçon suivante : Choisir des vérifications utiles