Aller au contenu
English

Corriger un bogue dans un code inconnu

  • Étude de cas 1
  • 150 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Cette étude de cas applique le débogage du module 4 et la révision du module 3 à un petit projet inconnu. Vous explorez le code, posez des questions ciblées à l'assistant, reproduisez et réduisez le bogue. Vous écrivez d'abord le test qui échoue, puis révisez la correction de l'assistant.

Ce que vous saurez faire

Corrigez le bogue d’une cliente dans un petit projet que vous n’avez jamais vu. Explorez le code avant de demander une modification, posez des questions ciblées à l’assistant et reproduisez vous-même le bogue. Réduisez ensuite l’entrée au minimum, écrivez le test qui échoue, corrigez le bogue avec l’assistant et révisez les différences. À la fin, comparez votre correction à celle des personnes qui ont écrit le code.

Étude de casPièce de portfolioDonnées synthétiques

Jeu de données
delivery-slots, l'outil de créneaux de livraison de Larkfield (créé pour cette étude de cas)
Licence
MIT
Durée
Environ 2,5 heures
S’exécute dans
VS Code, Python 3.12+, Git
Compétences utilisées
  • Explorer un code inconnu
  • Questions ciblées
  • Lire l'historique Git
  • Reproduire et réduire
  • D'abord le test qui échoue
  • Réviser les différences générées
  • Comparer les corrections avec une même mesure

Décompressez le projet de départ, ouvrez le dossier dans VS Code et suivez les étapes ci-dessous. Elles commencent par un nouvel environnement virtuel.

L’équipe du cours a écrit delivery-slots pour cette étude de cas, sous licence MIT. Il contient un historique Git, deux signalements et 35 tests. Larkfield, l’équipe de livraison, la cliente et les réservations sont inventés. Les secteurs postaux sont de vraies régions de tri d’acheminement de Montréal, mais leurs zones de livraison sont inventées. La session avec l’assistant est réelle : vous pouvez lire chaque requête et réponse dans la transcription enregistrée. La correction des responsables du projet, dans le projet terminé, est construite. L’équipe du cours l’a écrite comme la correction de l’équipe de livraison, pour vous permettre de comparer deux corrections.

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

Ce que vous devez savoir

Cette étude de cas applique tout le cours à du code qui n’est pas le vôtre. Elle s’appuie surtout sur Découper le travail en étapes (examiner avant de modifier), Reproduire d’abord, Choisir des vérifications utiles et Examiner les différences. Du cours sur Git, vous devez connaître les commits (modifications enregistrées) et git log, vus dans Suivre une première modification. Vous devez aussi connaître les différences, vues dans Lire et réviser les différences.

Ce qu’il vous faut sur votre ordinateur

  • Python 3.12 ou une version plus récente, Git et VS Code, comme dans les modules précédents. Environ 40 Mo d’espace disque libre.
  • Aucun compte et aucuns frais. Un assistant de programmation est facultatif : la session enregistrée est fournie, et un fichier de correctif contient sa modification.

Testé sur macOS (puce Apple) avec Python 3.14.6. Les commandes Windows sont écrites, mais n’ont pas été testées.

Le lundi matin, Grace, responsable du centre d’assistance, ajoute un signalement au projet de l’équipe de livraison. Une cliente, Solange, habite à Westmount, au code postal H3Z 2Y7. La page de livraison de Larkfield promet des créneaux en soirée pour la zone ouest les mardis et jeudis. Ils vont de 18 h à 20 h. Solange travaille le jour. À 10 h, elle a commandé un banc de jardin. Au paiement, elle n’a obtenu que trois créneaux de jour pour le mardi. Sa sœur à Notre-Dame-de-Grâce (H4A) a réservé une livraison en soirée pour la même journée.

L’équipe de livraison compte deux personnes, Delphine et Luis, qui sont toutes deux à un salon professionnel jusqu’au vendredi. Amira, qui s’occupe des outils du centre d’assistance, propose d’examiner le problème. Elle n’a jamais ouvert delivery-slots.

L’objectif. Solange obtient son créneau du mardi soir. Chaque client obtient les créneaux de sa propre zone. Et Delphine et Luis peuvent accepter la correction à leur retour. Elle comprend d’abord un test qui échoue, peu de différences et aucune modification que personne n’a demandée.

Partie Ce que vous faites Qui le fait
1 Explorer le projet : fichiers, commandes, parcours de la commande du signalement vous, puis l’assistant
2 Poser des questions ciblées sur une fonction l’assistant; vous vérifiez
3 Reproduire le bogue et lire l’historique vous
4 Réduire l’entrée au minimum vous
5 Écrire le test qui échoue et l’enregistrer dans un commit vous
6 Corriger le bogue l’assistant, dans vos limites
7 Réviser les différences l’assistant et vous
8 Comparer les corrections avec une même mesure et en recommander une vous
9 Exécuter le programme de bout en bout avec une nouvelle entrée vous
Fait Valeur
Projet delivery-slots : liste les créneaux de livraison d’un code postal, réserve un créneau, imprime la liste d’un chauffeur
Licence MIT, « Copyright (c) Nextia Learning »
Taille 9 fichiers Python (403 lignes), 7 fichiers de tests (317 lignes), 3 fichiers CSV
Historique 6 commits de Delphine, Luis et Grace; signalements 3 (fermé) et 12 (ouvert)
Dépendances aucune pour l’exécuter; pytest et ruff pour y travailler

Un code postal canadien compte six caractères, comme H3Z 2Y7. Les trois premiers, H3Z, forment la région de tri d’acheminement (RTA) : une partie d’une ville. Le fichier des zones de Larkfield, data/zones.csv, contient deux types de lignes. Une ligne peut désigner une RTA complète, comme H3Z. Elle peut aussi désigner les deux premiers caractères de plusieurs RTA, comme H3. Cela couvre H3A, H3B et toutes les autres RTA commençant par H3. Le README du projet donne la règle : la ligne d’une RTA complète l’emporte sur celle de ses deux premiers caractères. Leur position dans le fichier ne compte pas.

La fiche du projet indique ce qui est construit et liste les sommes de contrôle. L’historique a été écrit pour correspondre aux pratiques que vous exercez ici : un ancien signalement, sa correction et le bogue introduit par cette correction.

  1. Téléchargez le projet de départ depuis l’encadré en haut de cette page. Décompressez-le dans ~/projects. Vous obtenez le dossier delivery-slots.

  2. Dans VS Code, choisissez File > Open Folder (Fichier, ouvrir un dossier) et ouvrez delivery-slots. Ouvrez ensuite un terminal : Terminal > New Terminal (Terminal, nouveau terminal).

  3. Créez et activez un environnement virtuel, puis installez les outils à partir du fichier de verrouillage :

    Fenêtre de terminal
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install -q -r requirements-lock.txt

    Le fichier de verrouillage installe pytest 9.1.1 et ruff 0.16.10, avec quatre petits paquets nécessaires à pytest. Le programme lui-même n’a besoin que de Python.

  4. Vérifiez votre point de départ :

    Fenêtre de terminal
    git status
    python -m pytest
    git log --oneline
    Output (the end of pytest, then the log)
    On branch main
    nothing to commit, working tree clean
    ======================================== 35 passed in 0.10s ========================================
    c709b52 Add issue 12: no evening slots for H3Z
    182a550 Add evening slots for the west zone, and this week's bookings
    fc7e236 Accept postcodes typed without a space (fixes issue 3)
    ead395e Print the driver's list for a day and a zone
    a7f6c1c Book a slot for an order
    9fcf762 First version: list the slots of a postcode on a day

Ce que cela nous apprend. Les tests passent et l’arbre de travail est propre : c’est la référence de base de Préparer le dépôt. Les hachages sont identiques sur tous les ordinateurs. Le cours a créé l’historique avec des auteurs et des dates fixes. Les 35 tests passent, même si le bogue est réel. Les tests ne le couvrent donc pas, et une suite qui passe ne dit rien sur le signalement 12.

Dans une nouvelle ville, vous regardez la carte avant de demander votre chemin. Vous comprenez alors la réponse et remarquez quand elle est fausse.

Une carte du code répond à trois questions. Quels fichiers sont présents, et que fait chacun? Où commence une commande? Quelles fonctions la commande qui échoue traverse-t-elle? Faites cette carte avant toute modification. Comme l’a montré Découper le travail en étapes, modifier du code inconnu revient à deviner.

Faites vous-même la première carte. Cela prend cinq minutes :

Fenêtre de terminal
git ls-files
python -m delivery_slots --help
Output of the second command
usage: delivery_slots [-h] [--data DATA] [--now NOW] {slots,book,manifest} ...
Larkfield's delivery slots.
positional arguments:
{slots,book,manifest}
slots list the slots for a postal code on a day
book book a slot for an order
manifest print a driver's list for a day and a zone
options:
-h, --help show this help message and exit
--data DATA folder with zones.csv, slot-plan.csv and bookings.csv (default: data)
--now NOW use this time instead of the clock, for example 2026-10-19T10:00

La liste des fichiers contient delivery_slots/ (9 fichiers), tests/ (7 fichiers), data/ (3 fichiers CSV) et issues/ (2 fichiers). Lisez README.md et issues/12-no-evening-slots-for-h3z.md au complet. Ils sont courts. Ils décrivent les promesses du programme : trois zones, une heure limite à 20 h la veille, la règle des lignes de data/zones.csv et des créneaux en soirée pour la zone ouest.

Amira a ensuite demandé la même carte à l’assistant, en mode questions, sans fichier dans la conversation. L’assistant voyait la carte du dépôt d’Aider : les noms des fichiers et leurs fonctions. Aider a aussi demandé d’ajouter cli.py, car la requête le nomme. Voici sa requête, tirée de la transcription enregistrée (le texte du signalement est omis ici) :

Turn 1, prompt (end)
Before anyone changes code, I need a map of the project. Please answer from the
repository map:
1. In two or three lines: what does this project do?
2. Each file in delivery_slots/, with one line on what it does.
3. The functions that this command goes through, in order, from cli.py to the
lines it prints:
python -m delivery_slots --now 2026-10-19T10:00 slots "H3Z 2Y7" --day 2026-10-20
Do not change any file, and do not guess the cause yet.

La réponse listait chaque fichier avec une description correcte de son rôle, en une ligne. Elle suivait la commande à travers cli.main, cli.load, cli.cmd_slots, zones.zone_for et slots.slots_for, puis s’arrêtait là :

Turn 1, the assistant's reply (end of the first answer)
The actual zone, slot times, and availability cannot be established from the supplied file contents.
Internal calls within the lookup and slot functions are also not visible in the repository map. No
files have been changed, and this does not diagnose the issue’s cause.

C’est une bonne carte. Mais regardez ce qui s’est passé ensuite. La première réponse disait que le contenu de __init__.py et de __main__.py « n’avait pas été fourni ». Aider a ensuite proposé d’ajouter les sept fichiers nommés dans la réponse, et la deuxième réponse en demandait quatre autres. La session enregistrée a répondu oui à chaque question. Aider les a donc ajoutés et a envoyé deux autres requêtes : 12 fichiers en tout. La dernière réponse disait : « Mes affirmations précédentes selon lesquelles certains contenus manquaient étaient incorrectes ». Le tour 1 a coûté 3 appels au modèle et US$0.043, presque la moitié de toute la session.

Dans votre propre session, vous décidez. La carte était complète après le premier appel. « Non, la carte suffit » aurait évité deux appels.

Vérifiez la carte avec le code. Ouvrez delivery_slots/cli.py et trouvez cmd_slots. Cette fonction appelle zones.zone_for, puis slots.slots_for, puis imprime le résultat. La carte est correcte. Vous savez maintenant où chercher : les créneaux ou la zone.

Une question ciblée nomme une fonction, une entrée et un fait attendu, puis demande une réponse tirée du code. « Qu’est-ce qui ne va pas? » invite à deviner. « Que retourne cette fonction pour cette entrée, et à quelle ligne? » demande une preuve que vous pouvez vérifier.

Amira a ajouté trois fichiers : zones.py, postcodes.py et data/zones.csv. Voici sa deuxième requête :

Turn 2, prompt
Targeted questions. For H3Z 2Y7 on Tuesday, the customer was offered 08:00-10:00,
10:00-12:00 and 12:00-14:00. In data/slot-plan.csv, those are the city zone's
slots, not the west zone's.
1. Where in the code is the zone of a postcode decided? Name the function and
the lines.
2. Walk through that function for "H3Z 2Y7", with the rows of data/zones.csv
in their order. Which zone does it return, and at which step?
3. Which other areas in data/zones.csv get a wrong zone in the same way?
Answer from the code only. Do not change any file.
Turn 2, the assistant's reply (part)
In **`delivery_slots/zones.py`, `zone_for()`**, defined at line **28**. The deciding lines are
**34–37**:
...
At line 36, `"H3Z2Y7".startswith("H3")` is `True`. **Line 37 immediately returns `"city"` on the
first iteration.**
No subsequent rows are checked: `H2Y`, `H2Z`, `H2`, `H3N`, `H4`, `H3T`, `H3Y`, or `H3Z`. In
particular, the final `H3Z,west` row is never reached.

La réponse indiquait aussi que H3N, H3T et H3Y étaient incorrects de la même façon. Elle notait que H2Y et H2Z n’étaient pas touchés : leurs lignes précèdent la ligne plus générale H2. Le tour a coûté un appel, US$0.013.

C’est une affirmation précise. Mais ce n’est qu’une affirmation. Les deux parties suivantes la vérifient par des exécutions.

Exécutez la commande du signalement, comme Solange l’a vue le lundi à 10 h. L’option --now remplace l’horloge :

Fenêtre de terminal
python -m delivery_slots --now 2026-10-19T10:00 slots "H3Z 2Y7" --day 2026-10-20
python -m delivery_slots --now 2026-10-19T10:00 slots "H4A 3L2" --day 2026-10-20
Sortie
H3Z 2Y7 is in zone city.
Slots on Tuesday 20 October 2026 (orders close Monday at 20:00):
08:00-10:00 7 places left
10:00-12:00 9 places left
12:00-14:00 7 places left
H4A 3L2 is in zone west.
Slots on Tuesday 20 October 2026 (orders close Monday at 20:00):
08:00-12:00 11 places left
18:00-20:00 5 places left

Ce que cela nous apprend. Vous voyez ce que Solange a vu : trois créneaux de jour et aucun en soirée. La première ligne explique pourquoi : H3Z 2Y7 is in zone city (H3Z 2Y7 est dans la zone city). Le secteur de sa sœur obtient les créneaux de la zone ouest, dont celui du soir. L’heure limite n’est pas la cause : le lundi à 10 h, les commandes étaient ouvertes. Le plan des créneaux n’est pas non plus la cause : la zone ouest propose bien 18:00-20:00 les mardis.

git log liste les commits. git blame va un niveau plus loin : pour chaque ligne d’un fichier, il montre le dernier commit qui l’a modifiée. Dans du code inconnu, il vous indique pourquoi une ligne est ainsi. C’est souvent le chemin le plus rapide vers la cause.

Fenêtre de terminal
git log --oneline -- delivery_slots/zones.py
git blame -s -L 28,38 delivery_slots/zones.py
Sortie
fc7e236 Accept postcodes typed without a space (fixes issue 3)
9fcf762 First version: list the slots of a postcode on a day
^9fcf762 28) def zone_for(postcode: str, zones: dict[str, str]) -> str:
^9fcf762 29) """The zone of a postal code, for example "west" for "H4A 1B2".
^9fcf762 30)
fc7e236b 31) Customers type postal codes with or without the space ("H4A 1B2", "h4a1b2"),
fc7e236b 32) so the area is matched at the start of the postal code.
^9fcf762 33) """
fc7e236b 34) code = normalise(postcode).replace(" ", "")
fc7e236b 35) for area, zone in zones.items():
fc7e236b 36) if code.startswith(area):
fc7e236b 37) return zone
^9fcf762 38) raise UnknownPostcode(f"We do not deliver to {normalise(postcode)}.")

Chaque ligne de la recherche vient d’un seul commit : la correction de Luis pour le signalement 3. Ouvrez issues/3-postcode-without-a-space.md. Un client avait saisi H4A1B2 sans espace. La première version découpait le code postal à l’espace et ne trouvait donc aucune RTA. La correction de Luis cherchait plutôt une correspondance avec le secteur au début du code postal. Elle a corrigé le signalement 3, et son test passe. Elle a aussi créé le signalement 12. Regardez ce qu’elle a remplacé :

Fenêtre de terminal
git show fc7e236 -- delivery_slots/zones.py
Output (the changed lines)
def zone_for(postcode: str, zones: dict[str, str]) -> str:
"""The zone of a postal code, for example "west" for "H4A 1B2".
The row of the whole FSA wins over the row of its first two characters.
Customers type postal codes with or without the space ("H4A 1B2", "h4a1b2"),
so the area is matched at the start of the postal code.
"""
fsa = normalise(postcode).split(" ")[0]
if fsa in zones:
return zones[fsa]
if len(fsa) == 3 and fsa[:2] in zones:
return zones[fsa[:2]]
code = normalise(postcode).replace(" ", "")
for area, zone in zones.items():
if code.startswith(area):
return zone
raise UnknownPostcode(f"We do not deliver to {normalise(postcode)}.")

La première version cherchait d’abord la RTA complète, puis ses deux premiers caractères. Sa chaîne de documentation énonçait la règle. La boucle de Luis retourne la première ligne qui correspond, dans l’ordre du fichier. Et la ligne de documentation contenant la règle a disparu.

Le parcours de la commande du signalement dans cinq encadrés, de gauche à droite : la commande du signalement 12; cli.cmd_slots, qui demande la zone, puis les créneaux; zones.zone_for, en rouge et marqué comme la cause : H3Z2Y7 commence par H3, la première ligne, donc la fonction retourne city; slots.slots_for, en bleu : les créneaux du mardi de la zone city, corrects pour city; puis, en rouge et marqué comme le symptôme, ce que voit la cliente : trois créneaux de jour et aucun en soirée. Sous la cause, deux encadrés pointent vers elle : data/zones.csv dans son ordre, avec la ligne 1 H3 city qui correspond d'abord et la ligne 9 H3Z west jamais atteinte; puis git blame, lignes 34 à 37 du commit fc7e236, accepter les codes postaux saisis sans espace, corrige le signalement 3, où startswith a remplacé la recherche de RTA.
Le symptôme est à la fin du parcours. La cause est deux étapes plus tôt, et l'ordre du fichier de données et l'historique l'expliquent.
Description textuelle du diagramme

Cinq étapes de gauche à droite. La commande du signalement 12 mène à cli.cmd_slots, qui demande la zone à zones.zone_for. Cette étape est la cause : "H3Z2Y7" commence par "H3", la première ligne, donc la fonction retourne city. Ensuite, slots.slots_for retourne les créneaux de la zone city, ce qui est correct pour city. La cliente voit trois créneaux de jour et aucun en soirée : le symptôme. Sous la cause, data/zones.csv contient H3, city à la ligne 1 et H3Z, west à la ligne 9, jamais atteinte. git blame montre que les lignes 34 à 37 viennent du commit fc7e236, la correction du signalement 3.

L’entrée du signalement est une commande complète avec des fichiers de données, une date et une horloge. Reproduire d’abord vous a appris à la réduire jusqu’à ce qu’il ne reste que le bogue. Ici, appelez directement la fonction. Dans VS Code, créez un fichier shrink.py dans le dossier du projet :

shrink.py
from pathlib import Path
from delivery_slots.zones import load_zones, zone_for
zones = load_zones(Path("data") / "zones.csv")
print("H3Z 2Y7 ->", zone_for("H3Z 2Y7", zones))
# Every area of the file, as a made-up postal code: which ones get another zone?
# A two-character area gets an A, so H3 becomes H3A 1A1.
for area, zone in zones.items():
fsa = area if len(area) == 3 else area + "A"
got = zone_for(fsa + " 1A1", zones)
if got != zone:
print(f"{area}: file says {zone}, zone_for says {got}")
# The smallest input: two rows and one postal code.
print(zone_for("H3Z 2Y7", {"H3": "city", "H3Z": "west"}))
print(zone_for("H3Z 2Y7", {"H3Z": "west", "H3": "city"}))
Fenêtre de terminal
python shrink.py
Sortie
H3Z 2Y7 -> city
H3N: file says north, zone_for says city
H3T: file says west, zone_for says city
H3Y: file says west, zone_for says city
H3Z: file says west, zone_for says city
city
west

Ce que cela nous apprend. Chaque affirmation du tour 2 est vraie. H3N, H3T, H3Y et H3Z obtiennent la mauvaise zone, et les 5 autres secteurs sont corrects. Les deux dernières lignes forment l’entrée minimale qui échoue : deux lignes et un code postal. Les deux mêmes lignes dans l’autre ordre donnent la bonne réponse. Le résultat dépend donc de l’ordre des lignes, ce qu’une recherche ne devrait jamais faire.

Voici la nouvelle idée de cette étude de cas, en une image :

Un tableau pour zone_for de H3Z 2Y7, qui devient H3Z2Y7. Avant la correction : ligne 1, H3 city : H3Z2Y7 startswith H3 vaut True, la boucle s'arrête et retourne city, en rouge. Lignes 2 à 8 : jamais vérifiées. Ligne 9, H3Z west : jamais atteinte, la bonne ligne arrive trop tard, en ambre. Après la correction, secteur le plus long d'abord : les lignes de trois caractères d'abord, puis H3, H2 et H4; H3Z2Y7 commence par H3Z, donc la fonction retourne west, et l'ordre des lignes ne compte pas, en vert. Après la correction, une RTA sans ligne propre : H3A0G4 ne correspond à aucune ligne de trois caractères, puis H3 correspond, donc la fonction retourne city comme avant, en vert. En bas : une première correspondance dépend de l'ordre des lignes; la plus longue d'abord n'en dépend pas : la RTA complète H3Z l'emporte sur H3.
Une première correspondance s'arrête à la première ligne qui convient : l'ordre des lignes décide donc du résultat. Quand les lignes les plus longues sont essayées d'abord, la RTA complète l'emporte, quel que soit l'ordre.
Description textuelle du diagramme

Le même code postal, H3Z 2Y7 (H3Z2Y7 sans espace), deux recherches. Avant la correction, la ligne 1, H3, correspond déjà au début du code postal. La boucle s’arrête donc et retourne city. Les lignes 2 à 8 ne sont jamais vérifiées, et la ligne 9, H3Z, west, n’est jamais atteinte. Après la correction, le code essaie d’abord les lignes de trois caractères, puis H3, H2 et H4. H3Z correspond, donc la fonction retourne west. Une RTA sans ligne propre, comme H3A 0G4, ne correspond à aucune ligne de trois caractères. Elle correspond ensuite à H3 et obtient city comme avant.

Une première correspondance (par préfixe) est correcte seulement si aucune ligne ne forme le début d’une ligne placée plus loin. Le fichier de Larkfield enfreint cette règle : H3 est le début de H3N, H3T, H3Y et H3Z, et vient en premier. H2 est aussi le début de H2Y et H2Z. Mais ces lignes précèdent H2, donc elles sont correctes par chance. Une recherche correcte respecte la règle du README, quel que soit l’ordre. Chaque RTA compte trois caractères, donc il existe deux façons simples de faire. Chercher d’abord la RTA complète, puis ses deux premiers caractères, ou essayer d’abord les lignes les plus longues.

Supprimez shrink.py : c’était un outil d’exploration, pas une partie de la correction.

Écrivez le test avant que quiconque modifie le code, comme dans Choisir des vérifications utiles. Il doit échouer maintenant, pour la bonne raison, et passer après la correction. Utilisez les quatre secteurs trouvés lors de la réduction. Ajoutez ceci à la fin de tests/test_zones.py :

tests/test_zones.py (added at the end)
@pytest.mark.parametrize(
"postcode, zone",
[
("H3Z 2Y7", "west"),
("H3Y 1K5", "west"),
("H3T 1J4", "west"),
("H3N 2L8", "north"),
],
)
def test_fsa_rows_win(zones, postcode, zone):
"""Issue 12: "H3Z 2Y7" got the city zone's slots."""
assert zone_for(postcode, zones) == zone
Fenêtre de terminal
python -m pytest
Sortie (fin)
E AssertionError: assert 'city' == 'north'
...
FAILED tests/test_zones.py::test_fsa_rows_win[H3Z 2Y7-west] - AssertionError: assert 'city' == 'w...
FAILED tests/test_zones.py::test_fsa_rows_win[H3Y 1K5-west] - AssertionError: assert 'city' == 'w...
FAILED tests/test_zones.py::test_fsa_rows_win[H3T 1J4-west] - AssertionError: assert 'city' == 'w...
FAILED tests/test_zones.py::test_fsa_rows_win[H3N 2L8-north] - AssertionError: assert 'city' == '...
=================================== 4 failed, 35 passed in 0.10s ===================================

Les quatre nouveaux cas échouent avec 'city', le bogue lui-même. Les 35 autres passent toujours. Enregistrez seulement le test dans un commit, pour que l’historique montre son échec avant toute correction :

Fenêtre de terminal
git add tests/test_zones.py
git commit -m "Add a failing test for issue 12: H3Z 2Y7 is in zone west"

Amira a maintenant demandé la modification. Elle a fait passer Aider du mode questions au mode code, où il peut modifier les fichiers. Seuls zones.py et le fichier de tests étaient dans la conversation. Aider pouvait exécuter les tests après sa modification. Sa requête fixe les limites :

Turn 3, prompt
I committed a failing test: test_fsa_rows_win in tests/test_zones.py.
It fails four times. For example, zone_for("H3Z 2Y7", zones) returns "city";
expected "west". `python -m pytest -q` prints "4 failed, 35 passed".
Fix zone_for so that these tests pass.
- Change only delivery_slots/zones.py. Do not change the tests or the data.
- Postal codes typed without a space must still work (issue 3,
test_postcode_without_a_space).
- Keep the change small. In two lines, say why it fixes the cause.
Turn 3, the assistant's reply (first lines) and the test run
Matching longer prefixes first prevents the broad H3 entry from hiding specific FSA mappings.
Postcode normalization stays unchanged, so postcodes without spaces still work.
...
Applied edit to delivery_slots/zones.py
....................................... [100%]
39 passed in 0.06s

Le tour a coûté un appel, US$0.015.

Sans assistant, ou pour utiliser la modification enregistrée : téléchargez fix-issue-12.patch dans ~/projects, à côté du dossier du projet. Appliquez-le et exécutez les vérifications :

Fenêtre de terminal
git apply ../fix-issue-12.patch
python -m pytest
ruff check . && ruff format --check .
Sortie (fin)
======================================== 39 passed in 0.05s ========================================
All checks passed!
19 files already formatted

Avec votre propre assistant : suivez les trois mêmes étapes. Demandez la carte, puis posez les questions ciblées, puis demandez la correction avec les mêmes limites. Votre modification peut différer de celle enregistrée; la partie 8 vous donne une façon de la juger.

Fenêtre de terminal
git diff
Output (the changed lines)
@@ -32,7 +32,7 @@ def zone_for(postcode: str, zones: dict[str, str]) -> str:
so the area is matched at the start of the postal code.
"""
code = normalise(postcode).replace(" ", "")
- for area, zone in zones.items():
+ for area in sorted(zones, key=len, reverse=True):
if code.startswith(area):
- return zone
+ return zones[area]
raise UnknownPostcode(f"We do not deliver to {normalise(postcode)}.")

Révisez chaque ligne avec la liste de vérification d’Examiner les différences :

  • Lignes nécessaires. Les deux lignes modifiées sont nécessaires. La boucle essaie maintenant les secteurs les plus longs en premier. Les lignes à trois caractères passent donc avant H3, H2 et H4. Aucun autre fichier n’a changé. La chaîne de documentation n’a pas changé. Elle reste vraie, mais elle n’énonce pas la règle que le code respecte maintenant.
  • Contrats modifiés. La fonction retourne toujours une zone ou lève UnknownPostcode. Les fonctions qui l’appellent, cmd_slots et book, n’ont pas besoin de changement.
  • Hypothèses cachées. La correspondance la plus longue convient seulement parce que chaque secteur est le début d’une RTA. Et sorted(zones, key=len) suppose que chaque clé est du texte. Que se passe-t-il avec un code postal court ou incorrect, ou avec une clé incorrecte?
  • Comportement modifié volontairement, sans test. Le résultat ne dépend plus de l’ordre des lignes. C’est la règle du README. Mais aucun test ne le dit encore : les tests utilisent le fichier dans son seul ordre.

Pour les hypothèses cachées, Amira a demandé à l’assistant de réviser son propre changement (tour 4, mode question). Il a énuméré sept entrées, par exemple :

Turn 4, the assistant's reply (part)
| `"H3"` | Supplied CSV | `"city"` | An incomplete postcode is accepted because it matches a prefix.
|
| `"H3ZXYZ"` | Supplied CSV | `"west"` | Invalid trailing characters are not validated. |
| `"K1A 0B1"` | `{"": "west"}` | `"west"` | An empty prefix matches every postcode, including
otherwise unsupported ones. |

Certaines de ses entrées sont des codes postaux au mauvais format. D’autres sont des lignes incorrectes données directement à zone_for, comme le secteur vide "". Ce tour a coûté 2 appels, US$0.028 : au deuxième appel, l’assistant a demandé postcodes.py, qu’il avait déjà.

Ne croyez pas une révision sur parole; exécutez les vérifications. Créez un fichier review.py avec les sept entrées, puis exécutez-le sur le correctif et sur l’ancien code. git stash met temporairement de côté votre changement non validé, comme dans Demander des preuves :

review.py
from pathlib import Path
from delivery_slots.zones import UnknownPostcode, load_zones, zone_for
zones = load_zones(Path("data") / "zones.csv")
cases = [
("H3", zones),
("H3Z", zones),
("H3ZXYZ", zones),
("H3Z 2Y7", {"H3": "city", "h3z": "west"}),
("H3Z 2Y7", {"H3": "city", "H3Z ": "west"}),
("K1A 0B1", {"": "west"}),
("H3Z 2Y7", {3: "city"}),
]
for postcode, rows in cases:
where = "the file" if rows is zones else rows
try:
print(f"{postcode!r:10} {where} -> {zone_for(postcode, rows)}")
except UnknownPostcode as error:
print(f"{postcode!r:10} {where} -> refused: {error}")
except TypeError as error:
print(f"{postcode!r:10} {where} -> TypeError: {error}")
Fenêtre de terminal
python review.py
git stash -q
python review.py
git stash pop -q
Output: with the fix, then with the old code
'H3' the file -> city
'H3Z' the file -> west
'H3ZXYZ' the file -> west
'H3Z 2Y7' {'H3': 'city', 'h3z': 'west'} -> city
'H3Z 2Y7' {'H3': 'city', 'H3Z ': 'west'} -> city
'K1A 0B1' {'': 'west'} -> west
'H3Z 2Y7' {3: 'city'} -> TypeError: object of type 'int' has no len()
'H3' the file -> city
'H3Z' the file -> city
'H3ZXYZ' the file -> city
'H3Z 2Y7' {'H3': 'city', 'h3z': 'west'} -> city
'H3Z 2Y7' {'H3': 'city', 'H3Z ': 'west'} -> city
'K1A 0B1' {'': 'west'} -> west
'H3Z 2Y7' {3: 'city'} -> TypeError: startswith first arg must be str or a tuple of str, not int

Ce que cela nous apprend. Chaque affirmation de l’assistant est vraie. Et le correctif n’a aggravé le résultat d’aucune de ces entrées. L’ancien code attribuait la zone de la ville à chaque code postal court ou incorrect. Il échouait aussi de la même façon pour chaque ligne incorrecte. load_zones met les clés en majuscules et retire les espaces. Les lignes incorrectes ne peuvent donc pas venir du fichier de données. Un code postal au mauvais format est un problème distinct, que le ticket ne demandait pas de régler.

Amira a donc pris trois décisions. Accepter le correctif. Noter le problème de format dans un nouveau ticket pour les responsables. Et ajouter deux tests pour le comportement que le correctif a modifié volontairement. Supprimez review.py, puis ajoutez ceci à la fin de tests/test_zones.py :

tests/test_zones.py (added at the end)
def test_an_fsa_row_without_a_space(zones):
assert zone_for("h3z2y7", zones) == "west"
def test_the_order_of_the_rows_does_not_matter():
"""An FSA row wins over the row of its first two characters, in any order."""
for rows in ({"H3": "city", "H3Z": "west"}, {"H3Z": "west", "H3": "city"}):
assert zone_for("H3Z 2Y7", rows) == "west"
assert zone_for("H3A 0G4", rows) == "city"
Fenêtre de terminal
python -m pytest
git add -A
git commit -m "Match the whole FSA first (fixes issue 12)"
Output (end of pytest)
======================================== 41 passed in 0.08s ========================================

Erreur courante

« Revenez simplement à la première version »

Symptôme : après avoir lu git blame, Tomás dit que le bogue est apparu avec le changement de Luis. Il restaure la première version de zone_for, qui séparait le code postal à l’espace. Les quatre tests du ticket 12 réussissent. Puis la suite affiche 1 failed, 38 passed (1 échec, 38 réussites) : test_postcode_without_a_space échoue.

Cause : la première version contient le bogue du ticket 3. Un client qui tape H4A1B2 reçoit le message « Nous ne livrons pas à H4A1B2. » Annuler un changement annule aussi ce qu’il a corrigé. Ici, le test de Luis l’a détecté tout de suite. Sans ce test, le ticket 3 serait de retour en production.

Correctif : lisez le ticket qu’un commit (une validation dans Git) a corrigé avant d’annuler ce commit. Un correctif doit respecter les deux promesses : la RTA complète l’emporte, et les codes postaux fonctionnent sans espace. Le cours a mesuré cette solution candidate, construite par l’équipe du cours. Elle échoue aussi pour 2 des 12 lignes du tableau des secteurs de la partie 8.

Partie 8 : comparer les correctifs avec une même mesure

Section intitulée « Partie 8 : comparer les correctifs avec une même mesure »

Delphine a vu le ticket lundi soir à la foire. Elle a envoyé son propre correctif sur une branche, delphine/issue-12. Vous avez maintenant deux correctifs pour un seul bogue. Lequel l’équipe devrait-elle garder?

Les tests que vous écrivez avec un correctif tendent à confirmer ce correctif. Une comparaison équitable exige une mesure qui vient de l’exigence, et non d’un correctif. Ici, c’est un tableau des secteurs : 12 codes postaux, chacun avec la zone que data/zones.csv lui attribue, ou « refusé ». Selon la règle du README, la ligne d’une RTA complète l’emporte « peu importe la position des lignes dans data/zones.csv ». Le tableau vérifie donc chaque code postal deux fois : dans l’ordre des lignes du fichier, puis dans l’ordre inverse. Une ligne du tableau réussit seulement si les deux ordres donnent la zone attendue.

Le tableau couvre le ticket 12, le ticket 3 et les deux ensemble (h3z2y7). Il contient aussi les autres RTA qui ont leurs propres lignes. Il comprend deux RTA qui utilisent une ligne à deux caractères (H3A 0G4, H2W 1Y6). Il inclut aussi un secteur de Montréal que Larkfield ne dessert pas (H1A 0A1) et une autre ville (K1A 0B1).

Téléchargez area_table.py dans ~/projects, à côté du dossier du projet. Exécutez-le sur votre correctif :

Fenêtre de terminal
python -m pytest -q --rootdir=. ../area_table.py
Sortie
............ [100%]
12 passed in 0.01s

Décompressez le projet terminé dans un nouveau dossier, ~/projects/finished, pour éviter de remplacer le vôtre. Regardez ensuite son historique et le commit de Delphine :

Fenêtre de terminal
cd ~/projects/finished/delivery-slots
git log --oneline --all --graph
git show delphine/issue-12 -- delivery_slots/zones.py
Output of the graph (top)
* 155cc2d Match the whole FSA first (fixes issue 12)
| * 1f186ad Match the whole FSA first (fixes issue 12)
| * c94484f Add a failing test for issue 12: H3Z 2Y7 is in zone west
|/
* c709b52 Add issue 12: no evening slots for H3Z
Delphine's zones.py (the changed part)
def fsa_of(postcode: str) -> str:
"""The FSA of a postal code: "H3Z 2Y7" -> "H3Z", "h3z2y7" -> "H3Z".
The FSA is the first three characters of a Canadian postal code (a letter,
a digit, a letter), so this works with and without the space.
"""
return normalise(postcode).replace(" ", "")[:3]
def zone_for(postcode: str, zones: dict[str, str]) -> str:
"""The zone of a postal code, for example "west" for "H4A 1B2".
The row of the whole FSA wins over the row of its first two characters,
wherever the rows are in data/zones.csv: H3Z is not H3.
"""
fsa = fsa_of(postcode)
for area in (fsa, fsa[:2]):
if area in zones:
return zones[area]
raise UnknownPostcode(f"We do not deliver to {normalise(postcode)}.")

La règle de Delphine donne les mêmes réponses que celle de l’assistant, mais elle l’a écrite autrement. Elle fait deux recherches exactes : la RTA complète d’abord, puis ses deux premiers caractères, sans parcourir les lignes en boucle. Elle a donné un nom à la RTA, fsa_of, avec ses propres tests et une chaîne de documentation qui énonce la règle. Un de ses tests inverse les lignes du fichier. Son commit ajoute aussi une note au ticket 12 : trois réservations de cette semaine sont dans la mauvaise fourgonnette. Ouvrez issues/12-no-evening-slots-for-h3z.md sur sa branche pour la lire.

Le cours a mesuré cinq versions du projet, chacune dans une nouvelle copie du projet de départ. Chaque version a exécuté les mêmes 39 tests (les 35 du projet de départ et vos 4), ainsi que le tableau des secteurs. Deux versions sont des premières idées écrites par l’équipe du cours, marquées comme construites.

  • Code réel (le projet de départ, la session enregistrée)
  • Construit par l'équipe du cours
Les mêmes 12 codes postaux, dans les deux ordres des lignes, pour chaque correctif. Séparation : retour à la première version. Réorganisation : déplacer les lignes des RTA au début du fichier de données. Session : le correctif de l'assistant. Delphine : le correctif des responsables. Seuls les deux derniers réussissent les 12 lignes.
Description textuelle du graphique

Un diagramme à colonnes avec cinq colonnes. Le code non corrigé réussit 6 lignes sur 12. Le retour à la première version en réussit 10. Le déplacement des lignes des RTA au début du fichier de données en réussit 6. Le correctif de l’assistant en réussit 12, et celui des responsables en réussit 12.

Version Le changement Les 39 tests Tableau des secteurs Lignes qui échouent
non corrigé (référence de base) – 35 réussites, 4 échecs 6 sur 12 H3Z 2Y7, h3z2y7, H3Y, H3T, H3N; et H2Y dans l’ordre inverse
retour à la séparation (construit) code +6 −6 38 réussites, 1 échecs 10 sur 12 h3z2y7, H4A1B2 : le ticket 3 est de retour
réorganiser le fichier (construit) aucun code; 6 lignes de data/zones.csv déplacées les 39 réussissent 6 sur 12 les mêmes six que le code non corrigé, dans l’ordre inverse
le correctif de l’assistant (réel) code +2 −2 les 39 réussissent 12 sur 12 aucune
le correctif des responsables (construit) code +15 −6 les 39 réussissent 12 sur 12 aucune

Ce que cela nous apprend.

  • Les tests ne pouvaient pas distinguer deux de ces versions. « Réorganiser le fichier » déplace les six lignes des RTA au-dessus de H3, H2 et H4. La première correspondance les trouve alors en premier. Les 39 tests réussissent donc, y compris ceux du ticket 12. Mais le code dépend encore de l’ordre des lignes. La prochaine personne qui ajoute une ligne à la fin du fichier peut ramener le bogue. Dans l’ordre inverse, les mêmes six lignes échouent que dans le code non corrigé. Seul le tableau des secteurs, écrit à partir de la règle du README, le montre.
  • Le correctif de l’assistant et celui des responsables se comportent de la même façon. Ils donnent le même résultat pour les 12 lignes dans les deux ordres. C’est aussi le cas pour chaque code postal court ou incorrect de la partie 7. Le correctif des responsables est plus grand parce qu’il ajoute une fonction nommée, ses tests et une note.
  • La taille des différences n’est pas la mesure. « Réorganiser le fichier » ne change aucun code et ne fait que cacher le bogue. « Retour à la séparation » retire autant de lignes qu’il en ajoute et réintroduit le bogue du ticket 3.

Fusionnez un seul correctif et fermez l’autre en remerciant son auteur : les deux respectent la même règle. Le correctif d’Amira devrait passer en premier, car les clients de H3N, H3T, H3Y et H3Z sont touchés maintenant. Sa demande de tirage nomme les quatre RTA, le premier test qui a échoué et le tableau des secteurs. Elle suit ainsi Comprendre le code par vous-même. Au retour de Delphine, l’équipe pourra ajouter son fsa_of et ses deux recherches exactes dans un petit réusinage supplémentaire. Elle le fera si elle les trouve plus clairs qu’un tri. Ce sera un changement distinct, avec sa propre révision.

Deux éléments de la version de Delphine venaient de sa connaissance des affaires, et non du code. Elle a énoncé la règle dans la chaîne de documentation et a pensé aux réservations déjà faites. Le ticket ne demandait ni l’un ni l’autre. La prochaine partie montre que le deuxième élément compte.

Partie 9 : exécuter le tout de bout en bout avec de nouvelles entrées

Section intitulée « Partie 9 : exécuter le tout de bout en bout avec de nouvelles entrées »

Retournez à votre propre projet, ~/projects/delivery-slots. Exécutez tout le flux comme le font le passage à la caisse et le dépôt. Utilisez de nouvelles entrées, pas celles de vos tests : la commande de Solange, un nouveau client de H3N qui tape sans espace et un client hors des zones. Il est lundi, 15 h, avant l’heure limite :

Fenêtre de terminal
python -m delivery_slots --now 2026-10-19T15:00 slots "H3Z 2Y7" --day 2026-10-20
python -m delivery_slots --now 2026-10-19T15:00 slots h3n2l8 --day 2026-10-21
python -m delivery_slots --now 2026-10-19T15:00 book L-40213 "H3Z 2Y7" --day 2026-10-20 --start 18:00
python -m delivery_slots --now 2026-10-19T15:00 book L-40214 "H1A 0A1" --day 2026-10-20 --start 08:00
python -m delivery_slots manifest --day 2026-10-20 --zone west
python -m delivery_slots manifest --day 2026-10-20 --zone city
Sortie
H3Z 2Y7 is in zone west.
Slots on Tuesday 20 October 2026 (orders close Monday at 20:00):
08:00-12:00 11 places left
18:00-20:00 5 places left
H3N2L8 is in zone north.
Slots on Wednesday 21 October 2026 (orders close Tuesday at 20:00):
08:00-12:00 11 places left
12:00-16:00 11 places left
Booked order L-40213: H3Z 2Y7, zone west, Tuesday 20 October 2026 at 18:00.
Error: We do not deliver to H1A 0A1.
Zone west, Tuesday 20 October 2026: 3 deliveries
08:00 L-40124 H4A 1B2
18:00 L-40126 H4A 3L2
18:00 L-40213 H3Z 2Y7
Zone city, Tuesday 20 October 2026: 5 deliveries
08:00 L-40115 H3B 4W8
08:00 L-40118 H2Z 1B1
08:00 L-40121 H3Y 1K5
10:00 L-40128 H3G 1M8
12:00 L-40131 H3T 1J4

Ce que cela nous apprend. La commande de Solange est réservée pour mardi soir, dans la fourgonnette de l’ouest avec celle de sa sœur. Un code postal tapé sans espace obtient la zone du nord. H1A 0A1 est refusé, avec le code de sortie 1, comme avant. Mais la liste du chauffeur de la ville contient encore H3Y 1K5 et H3T 1J4. Ces clients ont réservé avant le correctif. Chaque réservation garde la zone qu’elle a reçue à ce moment-là. Le correctif empêche de nouvelles erreurs. Il ne déplace pas les anciennes réservations.

Pour toutes les trouver, créez wrong_zone.py. Il compare la zone de chaque réservation à celle que le code corrigé attribue aujourd’hui :

wrong_zone.py
from pathlib import Path
from delivery_slots.bookings import load_bookings
from delivery_slots.zones import load_zones, zone_for
zones = load_zones(Path("data") / "zones.csv")
for b in load_bookings(Path("data") / "bookings.csv"):
right = zone_for(b.postcode, zones)
if b.zone != right:
print(f"{b.order} {b.postcode:9} {b.day} booked in {b.zone}, should be {right}")
Output of python wrong_zone.py
L-40107 H3N 2L8 2026-10-19 booked in city, should be north
L-40121 H3Y 1K5 2026-10-20 booked in city, should be west
L-40131 H3T 1J4 2026-10-20 booked in city, should be west

Ce sont les trois mêmes commandes que dans la note de Delphine. Envoyez la liste à Grace pour que le centre d’assistance puisse les déplacer. Supprimez ensuite wrong_zone.py et annulez la réservation avec git restore data/bookings.csv. Dans le vrai magasin, le passage à la caisse crée la réservation, pas votre copie des données.

Un tableau des neuf étapes, avec la personne qui a fait chacune et ses preuves. 1 Carte : l'assistant, tour 1 en mode question, 3 appels au modèle, 0,043 $ US, 12 fichiers ajoutés en tout parce que le réglage disait oui. 2 Questions ciblées : l'assistant, tour 2, zone_for aux lignes 34 à 37 et H3N, H3T, H3Y, 1 appel, 0,013 $ US, chaque affirmation vérifiée par une exécution. 3 Reproduire : Amira, H3Z 2Y7 est dans la zone city. 4 Réduire : Amira, deux lignes de données, H3 puis H3Z donne city, H3Z puis H3 donne west. 5 Test qui échoue : Amira, 4 échecs, 35 réussites. 6 Correctif : l'assistant, tour 3, zones.py plus 2 moins 2, les plus longs en premier, 39 réussites, 1 appel, 0,015 $ US. 7 Révision : l'assistant, tour 4, puis Amira, les 7 affirmations sont vraies après exécution, 41 réussites. 8 Comparaison : Amira, assistant 12 sur 12, responsables 12 sur 12, réorganisation du fichier 6 sur 12. 9 De bout en bout : Amira, réservation à 18 h dans west, 3 anciennes réservations dans la mauvaise fourgonnette. Au bas : l'assistant a fait 4 étapes sur 9, pour 0,099 $ US, et chaque fait qu'il a donné a été vérifié par une exécution avant son utilisation.
L'assistant a fait quatre des neuf étapes. Chaque fait qu'il a donné a été vérifié par une exécution avant que quelqu'un l'utilise.
Description textuelle du diagramme

Neuf étapes. L’assistant a dressé la carte (3 appels) et répondu aux questions ciblées (1 appel). Il a fait le correctif (1 appel, 39 réussites) et l’a révisé : les sept affirmations étaient vraies après exécution. Amira a reproduit le bogue et l’a réduit à deux lignes de données. Elle a écrit le test qui échoue (4 échecs, 35 réussites). Elle a comparé les correctifs : 12 sur 12 pour les deux correctifs complets, 6 sur 12 pour « réorganiser le fichier ». Puis elle a exécuté le tout de bout en bout. Solange a obtenu une réservation, et trois anciennes réservations étaient dans la mauvaise fourgonnette. La session a coûté 0,099 $ US au total.

  • Le symptôme était loin de sa cause. Les créneaux étaient corrects; la zone était incorrecte à cause de l’ordre des lignes. La carte et une question ciblée ont trouvé le problème plus vite que la lecture de chaque fichier.
  • L’historique a expliqué le bogue, et un ancien test a empêché le correctif évident de ramener le ticket 3.
  • Les tests qui réussissent ne sont pas la mesure. « Réorganiser le fichier » a réussi les 39 tests. Le tableau des secteurs, écrit à partir de la règle du README, a détecté le problème.
  • L’assistant était utile et vérifiable. Sa carte, sa trace, son correctif et sa révision étaient corrects. Deux fois, il a demandé des fichiers qu’il avait déjà. Au tour 1, cela a coûté deux appels supplémentaires; au tour 4, un de plus. La session complète a coûté US$0.099 au tarif du déploiement au moment de l’enregistrement : 7 appels, 36,069 jetons en entrée et 2,701 en sortie. Les prix changent. Avec une offre gratuite ou sans assistant, vous ne payez rien.
  • Limites. Le projet et le correctif des responsables sont écrits pour le cours. Il n’y a qu’une session enregistrée. Une autre exécution, un autre modèle ou un autre assistant peut donner un correctif différent. Le tableau des secteurs sert à le juger. Le correctif ne vérifie pas le format du code postal : H3 seul obtient encore la zone de la ville. Il ne déplace pas les réservations qui étaient déjà incorrectes. Tout a été testé sur macOS seulement.
  • Données des clients dans les requêtes. La première requête d’Amira contenait le ticket complet, avec le nom, le code postal et le numéro de commande de Solange. Ici, les données sont inventées. Dans une vraie entreprise, cela envoie des données personnelles à un fournisseur de modèles. Vérifiez d’abord les règles de votre entreprise. Envoyez seulement ce que la question exige : la RTA H3Z et les créneaux observés, pas le courriel du client.
  • Les données sont personnelles aussi. data/bookings.csv contient des codes postaux et des numéros de commande. Ne le collez pas dans une requête. Ne laissez pas non plus un assistant exécuter des scripts sur le vrai système de réservation. wrong_zone.py lit seulement une copie, et une personne décide quoi déplacer.
  • Code qui appartient à une autre équipe. Amira a corrigé du code dont Delphine et Luis sont responsables, pendant leur absence. Elle a travaillé sur une branche, écrit le test qui échoue d’abord et limité les différences. Elle a laissé la fusion au processus normal de révision de l’équipe. Corrigez le bogue, pas toute la base de code. Le réusinage et la vérification du format sont des tickets distincts pour les responsables.
  • Dites comment vous avez travaillé. La demande de tirage indique qu’un assistant a écrit les deux lignes modifiées. Elle donne aussi les limites de la requête et la façon dont chaque affirmation a été vérifiée.

Publiez votre projet terminé dans un dépôt public. Il est sous licence MIT; gardez donc le fichier LICENSE. Ajoutez un CASE-STUDY.md :

CASE-STUDY.md (template)
# Fixing a bug in an unfamiliar codebase, with a coding assistant
## Problem
Issue 12: a customer in H3Z got the city zone's slots, with no evening slot.
## Approach
Map first, targeted questions, reproduce, shrink to two rows, failing test first,
assistant fix inside written limits, review by running, one measure for every fix.
## Results
4 failing tests → 41 passing; area table 12 of 12 (unfixed: 6; "reorder the file": 6,
although it passed every test). Three bookings made before the fix were on the wrong
van: listed for the help desk.
## What the assistant did, and how I checked it
Map, trace, fix (+2 −2 lines) and a self-review: every claim checked by a run.
## Limits
No postal code format check yet (H3 alone still gets city). One recorded session.

En deux phrases, pour une entrevue : « J’ai corrigé un bogue qui touchait une cliente dans une base de code que je n’avais jamais vue. J’ai utilisé un assistant pour la carte, le correctif et une révision, vérifié chaque affirmation par une exécution et écrit le test qui échoue d’abord. Un tableau de codes postaux tiré des données et de la règle du README a révélé un problème. Un correctif qui réussissait tous les tests dépendait encore de l’ordre des lignes. »

Pour aller plus loin :

  • Écrivez le ticket 13, « Vérifier le format du code postal », avec son propre test qui échoue pour H3, puis corrigez-le.
  • Transformez wrong_zone.py en commande check-bookings avec un test, dans une demande de tirage distincte.
  • L’heure limite utilise l’heure locale sans fuseau horaire. Découvrez ce qui se passe la nuit du changement d’heure et notez-le dans un ticket.

Vérifiez votre compréhension

Solange voyait les mauvais créneaux, mais le code des créneaux était correct. Expliquez le chemin de la commande au symptôme. Nommez deux preuves qui indiquaient la cause.

Afficher la réponse

cmd_slots demande la zone à zone_for, puis demande les créneaux de cette zone à slots_for. zone_for s’arrêtait à la première région correspondant au début du code postal. Et H3 est la première ligne de data/zones.csv. Donc, H3Z 2Y7 recevait city, et slots_for renvoyait correctement les créneaux de cette zone. Les preuves : la première ligne de sortie, H3Z 2Y7 is in zone city. (H3Z 2Y7 se trouve dans la zone city). Puis, l’entrée à deux lignes, qui donne city dans un ordre et west dans l’autre. git blame a ensuite montré que la recherche provenait de la correction du problème 3.

Vérifiez votre compréhension

« Réordonner le fichier » réussit les 39 tests. Pourquoi cela ne suffit-il pas pour accepter la fusion? Qu'est-ce qui a montré le problème?

Afficher la réponse

Les tests lisent data/zones.csv dans son seul ordre. Le fichier réordonné place simplement toutes les lignes de RTA en premier. Le code s’arrête toujours à la première ligne qui correspond. La prochaine ligne ajoutée au mauvais endroit ramènera donc le bogue. La règle du README dit que la RTA complète l’emporte, peu importe l’ordre des lignes. Le tableau des régions vérifie cette règle : il teste aussi chacun de ses 12 codes postaux avec les lignes dans l’ordre inverse. Là, « réordonner le fichier » échoue pour les six mêmes lignes que le code non corrigé.

Vérifiez votre compréhension

La révision de l'assistant listait sept entrées qui pouvaient encore poser problème. Qu'a fait Amira avec cette liste? Pourquoi n'a-t-elle pas demandé à l'assistant de tout corriger?

Afficher la réponse

Elle les a testées avec la correction et avec l’ancien code. Les affirmations étaient vraies. L’ancien code donnait le même résultat, ou un résultat pire, pour chacune de ces entrées. La correction ne les a donc pas causés : il s’agit d’un problème distinct, celui du format des codes postaux. Les lignes incorrectes ne peuvent pas venir du fichier de données, car load_zones nettoie les clés. Le problème signalé ne demandait aucun de ces changements, et le code appartient à une autre équipe. Elle a ajouté des tests pour les deux comportements que la correction changeait volontairement (h3z2y7 et l’ordre des lignes). Elle a consigné le problème de format dans un nouveau signalement destiné aux responsables.

Récapitulatif

  • Dressez d’abord la carte, vous-même, puis avec l’assistant. Vérifiez ensuite sa carte dans le code.
  • Les questions ciblées nomment une fonction et une entrée. Chaque réponse est une affirmation : vérifiez-la en exécutant le code.
  • Reproduire, lire l’historique, réduire : git blame a mené au problème 3. Deux lignes de données ont montré que la première correspondance dépendait de leur ordre.
  • D’abord un test qui échoue (4 échecs, 35 réussites), puis la correction de l’assistant dans les limites écrites (39 réussites).
  • Comparez avec une seule mesure, tirée de l’exigence : 12 sur 12 pour les deux corrections complètes. Seulement 6 pour « réordonner le fichier », qui réussissait tous les tests.
  • Le test de bout en bout avec une nouvelle entrée a montré les limites de la correction. Trois réservations étaient déjà attribuées à la mauvaise fourgonnette.

Ensuite, l’autre étude de cas : adapter un petit projet à un changement incompatible dans une dépendance. Vérifiez chaque changement proposé à l’aide du journal des modifications et des tests.

Leçon suivante : Mettre à jour une dépendance en toute sécurité