Aller au contenu
English

Réviser la sécurité et le traitement des données

  • Leçon 9
  • 45 min
  • Module 3 : Réviser le travail généré

Où nous en sommes

Dans les deux dernières leçons, nous avons révisé une modification ligne par ligne et vérifié un nouveau paquet avant de l'installer. Mais certains risques se cachent dans ce qu'une modification fait des données : les entrées, les secrets, les fichiers et les suppressions. Les tests couvrent rarement ces chemins, et une modification serviable peut supprimer le mauvais dossier ou afficher un secret. Dans cette leçon, nous suivons chaque valeur jusqu'à son utilisation, en partant d'une personne chargée du ménage avec un sac à déchets.

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

Ce que vous saurez faire

Découvrez ce qu’une modification fait avec les entrées, les secrets, les fichiers et les suppressions. Suivez chaque valeur depuis son entrée dans le programme jusqu’à son utilisation. Les tests couvrent rarement ces chemins; votre lecture doit donc les couvrir.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Le projet ~/projects/ticket-cleaner-assist, avec 34 passed (34 tests réussis) et un arbre de travail propre. Son environnement reste actif pendant toute la leçon.
  • Moins de 1 Mo d’espace libre, pour une copie jetable de l’instantané start.
  • Aucun compte, aucune clé et aucun paiement. Le jeton de cette leçon est inventé.

Une personne chargée du ménage avec un sac à déchets

Section intitulée « Une personne chargée du ménage avec un sac à déchets »

Vous demandez à une personne chargée du ménage : « Veuillez jeter les vieux papiers dans la boîte sur mon bureau. » À votre retour, la boîte est vide. Votre passeport était dedans, sous les papiers. La personne a fait ce que vous avez dit, mais pas ce que vous vouliez.

Le même jour, cette personne a dressé pour vous une liste de tout ce qui se trouvait sur le bureau. Elle l’a épinglée sur la porte d’entrée. La liste comprend le NIP inscrit sur la note dans votre tiroir.

Aucune des deux actions n’était malhonnête. Les deux ont utilisé quelque chose qui vous appartient d’une façon nuisible. Vos mots sont devenus « tout dans la boîte », et votre note privée est devenue un texte public.

La proposition E ajoute deux éléments à cli.py. L’équipe du cours l’a construite pour cette leçon. La modification est courte, 9 lignes, et elle semble utile. Voici les lignes ajoutées, sans la majeure partie du contexte :

candidate E, ticket_cleaner/cli.py (part)
@@ -1,5 +1,6 @@
import argparse
import logging
+import shutil
@@ -28,6 +29,11 @@ def make_parser() -> argparse.ArgumentParser:
+ parser.add_argument(
+ "--clean",
+ action="store_true",
+ help="delete old reports before writing the new one",
+ )
@@ -50,6 +56,7 @@ def main(argv: list[str] | None = None) -> int:
+ logger.debug("settings: %s", vars(settings))
@@ -63,6 +70,8 @@ def main(argv: list[str] | None = None) -> int:
summary = build_summary(tickets, rejected, args.status)
+ if args.clean:
+ shutil.rmtree(args.output.parent, ignore_errors=True)
write_json(summary, args.output)

Les 24 tests de l’instantané start réussissent, et ruff check . affiche All checks passed! (toutes les vérifications ont réussi). Aucun test n’utilise --clean ni le niveau de débogage, donc aucun test n’exécute les nouvelles lignes.

L’équipe du cours l’a exécutée dans des copies jetables et a mesuré deux résultats :

  • --clean --output summary.json a supprimé la copie du projet elle-même : 44 fichiers sont devenus 1, le nouveau summary.json. La commande a aussi supprimé le dossier .git, avec tous les commits (enregistrements des modifications). Ensuite, git status a affiché fatal: not a git repository (erreur fatale : ce n’est pas un dépôt Git). Git ne pouvait rien récupérer.
  • LOG_LEVEL=DEBUG a affiché le jeton secret à l’écran : 'api_token': 'demo-token-not-real'.

Le texte d’aide promettait de « supprimer les anciens rapports ». Le code supprime un dossier entier, et l’utilisateur choisit lequel.

L’idée : suivre chaque valeur jusqu’à son utilisation

Section intitulée « L’idée : suivre chaque valeur jusqu’à son utilisation »

Une révision de sécurité pose plusieurs fois la même question : d’où vient cette valeur, et où va-t-elle? Vous ne contrôlez pas une valeur provenant de l’extérieur du programme. Elle peut venir d’un argument, d’un fichier, d’une variable d’environnement ou du réseau. Suivez-la jusqu’à son utilisation, et vérifiez ce que la pire valeur possible peut y faire.

Quatre endroits demandent le plus d’attention. Ils forment la partie « Sécurité et données » de la liste de vérification :

  1. Validation des entrées. Avant d’utiliser une valeur comme chemin, commande ou nombre, le code la vérifie. Un chemin fourni en ligne de commande peut pointer n’importe où.
  2. Secrets. Un secret, comme un jeton ou un mot de passe, n’est jamais affiché, journalisé ni enregistré dans un fichier. Il n’est envoyé qu’à l’endroit prévu.
  3. Autorisations des fichiers. Le programme utilise vos autorisations. Il peut donc lire, modifier et supprimer tout ce que vous pouvez. Vous seul devriez pouvoir lire un fichier contenant un secret.
  4. Opérations destructrices. Une opération qui supprime ou écrase des données ne peut pas être annulée. Elle touche seulement ce que l’utilisateur a demandé, et seulement ce que le programme a créé. Elle demande d’abord une confirmation si la perte serait dommageable.

shutil.rmtree(folder) supprime un dossier et tout son contenu. La proposition E lui fournit args.output.parent, le dossier qui contient le fichier de sortie. Quel est ce dossier pour trois sorties possibles? Demandez à Python :

Fenêtre de terminal
python -c "from pathlib import Path; print(Path('out/summary.json').parent)"
python -c "from pathlib import Path; print(Path('summary.json').parent)"
python -c "from pathlib import Path; print(Path('summary.json').parent.resolve())"
Output (in the throwaway copy)
out
.
~/projects/ticket-cleaner-throwaway

Le parent de summary.json est ., le dossier courant : le projet. Donc, --clean --output summary.json signifie « supprimer le projet ». Le diagramme suit la valeur dans le code :

Un tableau pour la proposition E construite, qui exécute shutil.rmtree sur le parent de --output avec ignore_errors=True. Trois lignes. --output reports/summary.json, la valeur par défaut : le parent est reports, donc --clean supprime tous les anciens rapports dans reports. --output out/summary.json : le parent est out; selon la mesure, out contenait last-week.json, puis seulement summary.json. --output summary.json : le parent est le dossier courant, le projet lui-même; dans une copie jetable, 44 fichiers sont devenus 1. En bas : une valeur de la ligne de commande devient le dossier que shutil.rmtree supprime.
Suivez la valeur de --output : le fichier choisi par l'utilisateur détermine le dossier que la proposition E supprime, sans vérification ni question.
Description textuelle du diagramme

Le diagramme suit la valeur de --output dans la proposition E (construite). Le code est shutil.rmtree(args.output.parent, ignore_errors=True) : aucune vérification, aucune question et aucun message d’erreur. Trois lignes :

  • --output reports/summary.json, la valeur par défaut. Le parent est reports, le dossier du programme. --clean y supprime tous les anciens rapports, par exemple un rapport dont Grace a encore besoin.
  • --output out/summary.json. Le parent est out. Résultat mesuré : out/ contenait last-week.json; ensuite, il contenait seulement summary.json.
  • --output summary.json. Le parent est ., le dossier courant, qui est le projet lui-même. Résultat mesuré dans une copie jetable : 44 fichiers sont devenus 1, seulement summary.json.

En bas : une valeur de la ligne de commande devient le dossier que shutil.rmtree() supprime.

Même la valeur par défaut supprime plus que ce qu’annonce le texte d’aide. Un rapport de la semaine dernière, que quelqu’un a volontairement conservé dans reports/, disparaît. Et ignore_errors=True masque tous les problèmes, donc l’utilisateur ne voit rien d’inhabituel.

Vous allez exécuter la proposition E. Vous avez donc besoin d’un bac à sable : une copie que vous pouvez perdre. Exécutez la proposition E uniquement dans la copie jetable, jamais dans ticket-cleaner-assist. N’exécutez jamais --clean avec une sortie dans le dossier courant : cela supprime le dossier et son .git, avec tous les commits.

  1. Créez une copie jetable de start à côté de votre projet, puis faites-en un dépôt Git. Gardez l’environnement de votre projet actif : la copie a besoin des mêmes paquets.

    Fenêtre de terminal
    cd ~/projects
    cp -R nextia-learning-labs/C15/snapshots/start ticket-cleaner-throwaway
    cd ticket-cleaner-throwaway
    git init -q && git add -A && git commit -qm "Start"
  2. Copie jetable seulement. Vérifiez que vous êtes dedans : pwd doit se terminer par ticket-cleaner-throwaway. Appliquez ensuite la proposition E et lancez les vérifications :

    Fenêtre de terminal
    git apply ../nextia-learning-labs/C15/candidates/E-clean-and-debug.patch
    git diff --stat
    python -m pytest
    Sortie
    ticket_cleaner/cli.py | 9 +++++++++
    1 file changed, 9 insertions(+)
    ============================== 24 passed in 0.04s ==============================
  3. Créez un « ancien » rapport dans un dossier out, comme le ferait un utilisateur :

    Fenêtre de terminal
    python -m ticket_cleaner data/tickets.csv --output out/last-week.json

    Ensuite, affichez le contenu du dossier : ls out sur macOS et Linux, Get-ChildItem out dans PowerShell. Vous voyez last-week.json.

  4. Copie jetable seulement. --clean supprime un dossier. Utilisez exactement --output out/summary.json, jamais une sortie dans le dossier courant. Exécutez la nouvelle option, puis affichez de nouveau le contenu du dossier :

    Fenêtre de terminal
    python -m ticket_cleaner data/tickets.csv --clean --output out/summary.json
    ls out
    Output (the end)
    15 rows: 9 valid, 6 rejected.
    Report: out/summary.json
    summary.json

    last-week.json a disparu. Aucun avertissement ne s’est affiché.

N’essayez pas --output summary.json, même dans la copie jetable. L’équipe du cours l’a mesuré pour vous : le dossier a tout perdu, y compris .git. Un commit vous protège contre vos propres modifications, mais pas contre un programme qui supprime le dépôt.

Kwame révise le deuxième ajout. Il commence par sa question habituelle : « À quoi peut-il toucher? » La ligne de débogage touche aux paramètres, et les paramètres contiennent le jeton.

Dans le cours Python, la classe Settings protégeait le jeton avec field(repr=False). Voici un petit exemple avec un jeton inventé. print(s) et vars(s) montrent le même objet de deux façons :

Fenêtre de terminal
TICKETS_API_TOKEN=demo-token-not-real python -c "from ticket_cleaner.config import load_settings; s = load_settings(); print(s); print(vars(s))"
Sortie
Settings(tickets_url='https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C02/data/tickets.json', log_level='WARNING')
{'tickets_url': 'https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C02/data/tickets.json', 'api_token': 'demo-token-not-real', 'log_level': 'WARNING'}

Sur Windows, définissez la variable comme à l’étape 5 ci-dessous, puis exécutez la partie python -c. La première ligne vient de la description fournie par la classe, et repr=False omet le jeton. vars() retourne chaque champ dans un dictionnaire sans passer par la classe. Cette fonction contourne donc la protection. La proposition E journalise vars(settings).

  1. Copie jetable seulement, jeton inventé seulement. Exécutez le programme avec le niveau de débogage. Sur macOS et Linux, définissez les deux variables pour une seule commande :

    Fenêtre de terminal
    TICKETS_API_TOKEN=demo-token-not-real LOG_LEVEL=DEBUG python -m ticket_cleaner data/tickets.csv --output out/summary.json
    Output (the first line)
    DEBUG ticket_cleaner: settings: {'tickets_url': 'https://raw.githubusercontent.com/Nextia-Intelligence/nextia-learning-labs/main/C02/data/tickets.json', 'api_token': 'demo-token-not-real', 'log_level': 'DEBUG'}
Le jeton TICKETS_API_TOKEN=demo-token-not-real passe du terminal à load_settings et à la classe Settings, où api_token a field(repr=False). Deux branches. En vert : print(settings) ou logger.debug avec settings affiche Settings avec tickets_url et log_level seulement, car repr=False masque le jeton. En rouge : logger.debug avec vars(settings) affiche un dictionnaire contenant api_token demo-token-not-real, car vars lit chaque champ. Depuis la branche rouge, le jeton passe au terminal, à un fichier journal enregistré, à un journal de test ou de construction, puis à un rapport de bogue collé dans une conversation.
Où va le jeton. La classe le masque; vars() contourne la classe, et un journal de débogage le transporte vers des endroits lus par beaucoup de personnes.
Description textuelle du diagramme

Le jeton commence dans votre terminal, sous la forme TICKETS_API_TOKEN=demo-token-not-real (inventé). load_settings() le place dans un objet Settings, dont le champ api_token a field(repr=False). Le diagramme présente ensuite deux branches :

  • En vert : print(settings) ou logger.debug("%s", settings) affiche Settings(tickets_url='https://…/tickets.json', log_level='WARNING'). repr=False masque le jeton.
  • En rouge : logger.debug("settings: %s", vars(settings)) affiche {'tickets_url': '…', 'api_token': 'demo-token-not-real', 'log_level': 'DEBUG'}, car vars() lit chaque champ.

Depuis la branche rouge, le jeton atteint le terminal, les fichiers journaux, les journaux de construction et les rapports de bogues collés dans des conversations. Chaque endroit a plus de lecteurs que votre terminal.

Les journaux de débogage circulent. Les gens activent le niveau de débogage précisément quand quelque chose va mal, puis partagent la sortie pour obtenir de l’aide. Un secret dans une ligne de débogage finira donc par atteindre quelqu’un qui ne devrait pas l’avoir. Si un vrai jeton fuit, supprimer la ligne de l’écran ne règle pas le problème. Le propriétaire du service doit révoquer le jeton et en créer un nouveau.

Autorisations des fichiers : votre programme agit comme vous

Section intitulée « Autorisations des fichiers : votre programme agit comme vous »

Chaque programme que vous exécutez a vos autorisations. C’est pourquoi shutil.rmtree() pouvait supprimer le projet : vous le pouviez, donc le programme aussi. Une révision ne peut pas changer cela, mais elle peut garder le programme dans ses propres dossiers.

Les autorisations protègent aussi les secrets stockés. Si vous gardez le jeton dans un fichier .env, vérifiez qui peut le lire. Sur macOS et Linux, dans la copie jetable :

Fenêtre de terminal
printf "TICKETS_API_TOKEN=demo-token-not-real\n" > .env
ls -l .env
chmod 600 .env
ls -l .env
Output (the file mode and name)
-rw-r--r--@ .env
-rw-------@ .env

rw-r--r-- signifie que vous pouvez lire et écrire le fichier, et que tous les autres utilisateurs de l’ordinateur peuvent le lire. Après chmod 600, vous seul le pouvez. (Le @ indique des informations supplémentaires sur le fichier dans macOS; Linux ne l’affiche pas.) git status ne liste pas .env, car .gitignore le nomme. Sur Windows, seuls votre compte et les administrateurs peuvent normalement lire les fichiers de votre dossier utilisateur. L’équipe du cours n’a pas testé Windows.

  1. Remettez la copie jetable à start. git clean supprime les fichiers que Git ne suit pas. Regardez donc d’abord avec -n, qui les liste seulement :

    Fenêtre de terminal
    git restore .
    git clean -n -d
    git clean -fd
    Sortie
    Would remove out/
    Removing out/

    git status --short n’affiche maintenant rien. .env reste, car Git l’ignore, donc git clean n’y touche pas. Vous supprimerez toute la copie après l’exercice du module.

git clean -fd est aussi une opération destructrice. L’exécution avec -n est l’étape « demander d’abord » que la proposition E n’avait pas.

Elle la rejette. Aucun des deux ajouts ne faisait partie d’une tâche, donc la vérification du périmètre suffit à elle seule. Les constats de sécurité montrent pourquoi cette règle existe. Sa révision nomme chaque constat avec ses preuves :

  • Opération destructrice, aucune validation des entrées : shutil.rmtree(args.output.parent, ignore_errors=True) supprime n’importe quel dossier vers lequel --output pointe; --output summary.json supprime le projet, y compris .git.
  • Secret dans un journal : logger.debug("settings: %s", vars(settings)) affiche le jeton au niveau de débogage, en contournant field(repr=False).

Si Grace demande un jour de supprimer les anciens rapports, ce sera une nouvelle tâche avec sa propre fiche. Ses critères pourraient être : supprimer seulement les fichiers .json que le programme a écrits dans reports/. Les lister et demander d’abord une confirmation. Un test exécute cette opération dans un dossier temporaire. Si journaliser les paramètres au niveau de débogage est utile, le code journalise settings, pas vars(settings). Un test vérifie que le jeton n’apparaît pas dans la sortie.

Faites cette révision pour chaque modification qui lit une entrée, touche aux fichiers, utilise le réseau, traite un secret ou supprime quelque chose. Cela concerne la plupart des modifications d’un programme en ligne de commande. Il suffit de quelques minutes : listez les valeurs provenant de l’extérieur, puis suivez chacune d’elles.

Cette méthode a des limites. Vous trouvez ce que vous suivez, et un problème subtil peut se cacher deux fonctions plus loin. Un spécialiste de la sécurité comme Kwame révise aussi tout programme qui traite des données clients ou fonctionne sur un serveur. La liste de vérification ne remplace pas cette révision. Elle garantit que les chemins évidents ont été suivis chaque fois.

Erreur courante

Une modification destructrice testée dans le vrai projet

Symptôme : Tomás veut voir ce que fait --clean. Il applique donc la proposition E dans son propre ticket-cleaner-assist et l’exécute avec --output summary.json. Le dossier est vide, sauf pour summary.json. git status affiche fatal: not a git repository.

Cause : la modification supprime le dossier parent de la sortie, et .git était dedans. Git ne peut pas restaurer ce qu’il n’a plus. Ses commits sur la branche ont aussi disparu, sauf s’il les a poussés ailleurs.

Solution : il n’y a aucune solution dans ce dossier. Il copie l’instantané du dernier module terminé et refait les étapes de la leçon, comme l’indiquent les étapes de réinitialisation. Une branche poussée, comme dans le cours Git, aurait conservé ses commits. La prochaine fois, il exécutera une modification inconnue uniquement dans une copie jetable, avec un dossier de sortie qu’il peut perdre.

À vous de jouer : un ancien risque dans le code existant

Section intitulée « À vous de jouer : un ancien risque dans le code existant »

La proposition E n’est pas le seul endroit où --output compte. Le code du cours Python écrit le rapport à l’endroit vers lequel --output pointe. Dans la copie jetable, avant l’exécution, faites une prédiction : que se passe-t-il avec cette commande?

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

Exécutez-la, puis exécutez git status --short et head -3 data/web-form-export.csv. Quelle ligne de la liste de vérification ne respecte-t-elle pas? Que proposeriez-vous?

Afficher la réponse

Le programme écrase l’exportation de Grace avec le rapport JSON et l’annonce calmement : Report: data/web-form-export.csv (rapport : data/web-form-export.csv).

Sortie
M data/web-form-export.csv
{
"status": "open",
"valid_records": 9,

Il ne respecte pas « Aucun fichier n’est supprimé, et aucun fichier de données n’est modifié ». Ni « Rien n’est supprimé ou écrasé sans demande de l’utilisateur ». L’utilisateur l’a bien demandé, par erreur. Une proposition pour une tâche distincte : refuser une sortie dans data/, avec le code de sortie 2 et un message clair. Ou refuser d’écraser un fichier qui n’est pas un rapport .json. C’est du code ancien, pas une modification d’un assistant. La révision des risques s’applique à chaque ligne dont vous êtes responsable. Rétablissez la copie avec git restore ..

Exercice du module : comparer deux versions candidates

Section intitulée « Exercice du module : comparer deux versions candidates »

L’exercice du module : comparez deux correctifs candidats et rejetez celui qui contient un défaut subtil. Les deux ajoutent l’option --category à start et réussissent leurs propres tests. L’un vient de la vraie session aux limites définies du module 2. L’autre, la version candidate C, a été construit pour le cours : court, soigné et formaté.

Lisez d’abord les deux dans l’explorateur. Prédisez lequel échoue et quel critère d’acceptation il enfreint. Ensuite, lancez les vérifications cachées.

Explorer

Deux versions candidates qui réussissent leurs propres tests

Candidat 1

réel : une session enregistrée (le cahier de la tâche)

git diff --stat
5 fichiers, +145 −4
Ses propres tests
35 passed in 0.05s
ruff format --check
échoué
Afficher le code de ticket_cleaner/
diff --git a/ticket_cleaner/cli.py b/ticket_cleaner/cli.py
--- a/ticket_cleaner/cli.py
+++ b/ticket_cleaner/cli.py
@@ -28,6 +28,12 @@ def make_parser() -> argparse.ArgumentParser:
         choices=sorted(STATUSES),
         help="which tickets to count (default: open)",
     )
+    parser.add_argument(
+        "--category",
+        action="append",
+        metavar="NAME",
+        help="count only this category; repeat for more (case-insensitive)",
+    )
     parser.add_argument(
         "--output",
         type=Path,
@@ -62,7 +68,7 @@ def main(argv: list[str] | None = None) -> int:
     for record in rejected:
         logger.warning("row %d rejected: %s", record.row, "; ".join(record.problems))
 
-    summary = build_summary(tickets, rejected, args.status)
+    summary = build_summary(tickets, rejected, args.status, categories=args.category)
     write_json(summary, args.output)
     logger.info("wrote %s", args.output)
     print(f"{len(rows)} rows: {len(tickets)} valid, {len(rejected)} rejected.")
diff --git a/ticket_cleaner/report.py b/ticket_cleaner/report.py
--- a/ticket_cleaner/report.py
+++ b/ticket_cleaner/report.py
@@ -21,10 +21,20 @@ def average_priority(tickets: list[Ticket]) -> float | None:
     return round(sum(ticket.priority for ticket in tickets) / len(tickets), 1)
 
 
-def build_summary(tickets: list[Ticket], rejected: list[Rejected], status: str) -> dict:
-    """Return the report as a dictionary that can be saved as JSON."""
+def build_summary(
+    tickets: list[Ticket],
+    rejected: list[Rejected],
+    status: str,
+    categories: list[str] | None = None,
+) -> dict:
+    """Return the report, optionally selecting normalized category names."""
     selected = filter_by_status(tickets, status)
-    return {
+    chosen_categories = None
+    if categories is not None:
+        chosen_categories = sorted({category.strip().lower() for category in categories})
+        category_names = set(chosen_categories)
+        selected = [ticket for ticket in selected if ticket.category in category_names]
+    summary = {
         "status": status,
         "valid_records": len(tickets),
         "selected": len(selected),
@@ -32,3 +42,6 @@ def build_summary(tickets: list[Ticket], rejected: list[Rejected], status: str)
         "average_priority": average_priority(selected),
         "rejected": [{"row": r.row, "problems": r.problems} for r in rejected],
     }
+    if chosen_categories is not None:
+        summary["categories"] = chosen_categories
+    return summary

Candidat 2

construit pour le cours

git diff --stat
3 fichiers, +24 −0
Ses propres tests
25 passed in 0.04s
ruff format --check
réussi
Afficher le code de ticket_cleaner/
diff --git a/ticket_cleaner/cli.py b/ticket_cleaner/cli.py
--- a/ticket_cleaner/cli.py
+++ b/ticket_cleaner/cli.py
@@ -28,6 +28,12 @@ def make_parser() -> argparse.ArgumentParser:
         choices=sorted(STATUSES),
         help="which tickets to count (default: open)",
     )
+    parser.add_argument(
+        "--category",
+        action="append",
+        metavar="NAME",
+        help="count only this category; repeat for more",
+    )
     parser.add_argument(
         "--output",
         type=Path,
@@ -59,10 +65,15 @@ def main(argv: list[str] | None = None) -> int:
         return 1
 
     tickets, rejected = split_records(rows)
+    if args.category:
+        wanted = {name.strip().lower() for name in args.category}
+        tickets = [ticket for ticket in tickets if ticket.category in wanted]
     for record in rejected:
         logger.warning("row %d rejected: %s", record.row, "; ".join(record.problems))
 
     summary = build_summary(tickets, rejected, args.status)
+    if args.category:
+        summary["categories"] = sorted(wanted)
     write_json(summary, args.output)
     logger.info("wrote %s", args.output)
     print(f"{len(rows)} rows: {len(tickets)} valid, {len(rejected)} rejected.")

Les résultats des 8 vérifications cachées pour chaque candidat.

Les 8 vérifications d’acceptation cachées
Vérification cachéeCandidat 1Candidat 2
--category billing counts only the billing ticketsréussiréussi
--category billing --category shipping counts bothréussiréussi
--category ' Billing ' (capital letter, spaces) still finds billingréussiréussi
the report lists the chosen categories, sorted, in small lettersréussiréussi
without --category, the report is exactly as beforeréussiréussi
valid_records (9) and rejected (6) still describe the whole fileréussiéchoué
an unknown category gives 0 selected and exit code 0réussiréussi
--help describes --categoryréussiréussi
La version candidate 1 est réelle (la session enregistrée avec la fiche de tâche); la version candidate 2 est C, construite pour le cours. Résultats des 8 vérifications d'acceptation cachées, exécutées par l'équipe du cours.
Description textuelle de l’explorateur

Deux versions candidates pour l’option --category, toutes deux sous forme de correctifs pour start. La version candidate 1 est réelle, tirée de la session enregistrée avec la fiche de tâche : 5 fichiers, +145 −4. Ses propres tests donnent 35 passed (35 tests réussis); ruff format --check échoue. La version candidate 2 est C, construite : 3 fichiers, +24 −0. Ses propres tests donnent 25 passed (25 tests réussis); ruff format --check réussit. Chaque carte peut afficher le code dans ticket_cleaner/.

Le tableau des 8 vérifications d’acceptation cachées : la version candidate 1 réussit les 8. La version candidate 2 en réussit 7 et en échoue une : « valid_records (9) et rejected (6) décrivent toujours le fichier entier ».

Trouvez maintenant vous-même le comportement défaillant dans la copie jetable :

  1. Appliquez la version candidate C et lancez ses vérifications :

    Fenêtre de terminal
    git apply ../nextia-learning-labs/C15/candidates/C-filter-before-summary.patch
    git diff --stat
    python -m pytest
    ruff format --check .
    Sortie
    README.md | 1 +
    tests/test_cli.py | 12 ++++++++++++
    ticket_cleaner/cli.py | 11 +++++++++++
    3 files changed, 24 insertions(+)
    ============================== 25 passed in 0.03s ==============================
    15 files already formatted

    Toutes les vérifications que l’auteur a exécutées réussissent.

  2. Vérifiez le critère 5 de la fiche : valid_records et rejected ne changent pas avec --category.

    Fenêtre de terminal
    python -m ticket_cleaner data/tickets.csv --category billing
    Sortie
    15 rows: 3 valid, 6 rejected.
    Report: reports/summary.json

    Le rapport contient "valid_records": 3. La même commande dans votre projet affiche 15 rows: 9 valid, 6 rejected. (15 lignes : 9 valides, 6 rejetées) et donne "valid_records": 9.

  3. Restaurez la copie, puis supprimez-la :

    Fenêtre de terminal
    git restore . && git clean -fd
    cd ..
    rm -rf ticket-cleaner-throwaway

    Vérifiez le nom du dossier avant d’appuyer sur Entrée.

Vérification de fin d’exercice : expliquez le défaut de la version candidate C dans vos mots et indiquez un comportement défaillant. Écrivez ensuite un test qui échoue avec C et réussit avec la modification acceptée.

Afficher une solution détaillée

Le défaut. La version candidate C filtre dans cli.py, avant le résumé : tickets = [ticket for ticket in tickets if ticket.category in wanted]. Elle transmet ensuite la liste filtrée à build_summary(). Mais build_summary() compte valid_records à partir de la liste reçue. Avec --category billing, le rapport indique donc que le fichier contient 3 billets valides : ceux de facturation, tous statuts confondus. Le fichier en contient 9. La ligne affichée est aussi fausse : 15 rows: 3 valid, 6 rejected. (15 lignes : 3 valides, 6 rejetées) donne un total de 9 lignes, pas 15.

Le comportement défaillant. python -m ticket_cleaner data/tickets.csv --category billing donne "valid_records": 3. Le critère 5 attend 9. Un tableur qui affiche les « billets valides » changerait maintenant selon l’équipe qui le consulte.

Pourquoi les tests n’ont pas détecté le défaut. Le seul nouveau test de la version candidate C vérifie selected, by_category et categories. Il ne regarde jamais valid_records. Le test vérifie ce à quoi l’auteur a pensé, pas ce que la fiche demande.

Un test pour le défaut, par exemple dans tests/test_cli.py :

def test_category_does_not_change_the_whole_file_counts(tmp_path):
output = tmp_path / "billing.json"
assert main(["data/tickets.csv", "--category", "billing", "--output", str(output)]) == 0
summary = json.loads(output.read_text(encoding="utf-8"))
assert summary["valid_records"] == 9
assert len(summary["rejected"]) == 6

L’équipe du cours l’a exécuté sur les deux versions :

On candidate C
E assert 3 == 9
============================== 1 failed in 0.03s ===============================
On the accepted change
============================== 1 passed in 0.02s ===============================

Votre projet contient déjà la même vérification un niveau plus bas : test_categories_do_not_change_the_whole_file_counts dans tests/test_report.py. La décision : rejeter la version candidate C, avec cette commande et ce test comme preuves.

Vous avez terminé le module quand vous pouvez montrer ces éléments dans votre propre projet :

  • git log --oneline montre huit commits (enregistrements des modifications) sur feature/category-option. Les deux derniers sont Add the --category option, after review (ajouter l’option –category après révision) et Add a checklist for reviewing a generated change (ajouter une liste de vérification pour réviser une modification générée).

  • python -m pytest affiche 34 passed (34 tests réussis), et ruff format --check . affiche 21 files already formatted (21 fichiers déjà formatés).

  • python -m ticket_cleaner data/tickets.csv --category billing --category shipping donne "by_category": {"billing": 2, "shipping": 1} et "categories": ["billing", "shipping"].

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

    Fenêtre de terminal
    diff -rq . ../nextia-learning-labs/C15/snapshots/end-of-m03 -x .git -x .venv -x reports -x __pycache__ -x .pytest_cache -x .ruff_cache
  • Pour chacune des versions candidates A, C, D et E, vous pouvez nommer la raison du rejet et les preuves.

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

Vérifiez votre compréhension

Nommez les quatre parties d'une révision de la sécurité et des données. Pour chaque constat, indiquez la ligne concernée dans la version candidate E, ou « aucun constat ».

Afficher la réponse
  • Validation des entrées : shutil.rmtree(args.output.parent, ignore_errors=True) utilise un chemin provenant de la ligne de commande sans vérification.
  • Secrets : logger.debug("settings: %s", vars(settings)) affiche le jeton au niveau de débogage.
  • Autorisations des fichiers : aucune ligne ne modifie les autorisations. Mais le programme utilise les vôtres. Ainsi, rmtree() peut supprimer tout ce que vous pouvez supprimer, y compris .git.
  • Opérations destructrices : la même ligne rmtree() supprime un dossier entier sans demander, et ignore_errors=True masque tous les problèmes.

Vérifiez votre compréhension

La classe Settings utilise field(repr=False). Pourquoi la version candidate E a-t-elle quand même affiché le jeton? Que devrait consigner une ligne de débogage sûre?

Afficher la réponse

repr=False modifie seulement la description propre à la classe, qu’utilisent print(settings) et "%s" % settings. vars(settings) renvoie les champs de l’objet sous forme de dictionnaire sans consulter la classe. Le jeton s’y trouve donc. Une ligne de débogage sûre consigne settings directement, ou seulement les champs non secrets, comme settings.tickets_url. Un test peut exécuter le programme au niveau de débogage avec un jeton inventé et vérifier son absence dans la sortie.

Vérifiez votre compréhension

Prédisez : avec la version candidate E, que supprime python -m ticket_cleaner data/tickets.csv --clean, sans --output? Expliquez à partir du code.

Afficher la réponse

La sortie par défaut est reports/summary.json, donc args.output.parent est reports. shutil.rmtree() supprime le dossier reports/ entier, avec tous les anciens rapports qu’il contient. Ensuite, write_json() recrée le dossier avec seulement le nouveau summary.json. Rien ne demande de confirmation ni n’avertit. C’est le cas le moins dommageable, mais il supprime quand même plus que ce qu’annonce le texte d’aide. Tout fichier que quelqu’un a enregistré dans reports/ disparaît.

Récapitulatif

Cette leçon

  • Une révision de sécurité suit chaque valeur provenant de l’extérieur du programme jusqu’à son utilisation : entrées, secrets, autorisations des fichiers et opérations destructrices.
  • La version candidate E (construite) a réussi les 24 tests. --clean supprimait le dossier de --output : avec summary.json, le projet et .git. Sa ligne de débogage affichait le jeton, car vars() contourne field(repr=False).
  • Exécutez une modification inconnue seulement dans une copie jetable. Demandez d’abord ce qui sera supprimé : git clean -n avant git clean -fd.

Module 3 : réviser le travail généré

  • Révisez chaque différence ligne par ligne avec docs/review-checklist.md : portée, comportement et contrats, dépendances, sécurité et données, et vérifications que vous exécutez vous-même.
  • Une exécution de tests réussie n’est pas une révision. Les versions candidates A, C, D et E ont toutes échoué pour des raisons que leurs propres tests n’ont pas révélées.
  • Avant tout pip install : le paquet existe, il est nécessaire, il est maintenu et convient, et sa licence convient.
  • Votre projet correspond à end-of-m03 : l’option --category acceptée et la liste de vérification, 34 passed.

Ensuite, dans le module 4, vous revenez au bogue de Grace. Vous le reproduisez d’abord, puis demandez des preuves à l’assistant plutôt qu’une réécriture rapide.

Leçon suivante : Reproduire d'abord