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.
Leçon 9 sur 15 · Développement logiciel assisté par l'IARéviser la sécurité et le traitement des données
1. Mettre en place un environnement de travail sûr
2. Rédiger des tâches exploitables
3. Réviser le travail généré
4. Déboguer et tester avec l'assistant
5. Livrer un travail facile à maintenir
Ce que vous saurez faire
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 main
Ce que vous devez savoir
- La liste de vérification pour la révision, dans Examiner les différences.
- Les variables d’environnement, la classe
Settingsetfield(repr=False), dans Configuration et secrets. - Les niveaux de journalisation, dans Exceptions et journalisation.
- Un bac à sable et une copie jetable, dans Contexte et limites.
Ce qu’il vous faut sur votre ordinateur
- Le projet
~/projects/ticket-cleaner-assist, avec34 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.
Le problème : une modification qui semble utile
Section intitulée « Le problème : une modification qui semble utile »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 :
@@ -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.jsona supprimé la copie du projet elle-même : 44 fichiers sont devenus 1, le nouveausummary.json. La commande a aussi supprimé le dossier.git, avec tous les commits (enregistrements des modifications). Ensuite,git statusa 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=DEBUGa 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 :
- 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ù.
- 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.
- 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.
- 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.
Un petit exemple : le parent de trois chemins
Section intitulée « Un petit exemple : le parent de trois chemins »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 :
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())"out.~/projects/ticket-cleaner-throwawayLe 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 :
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 estreports, le dossier du programme.--cleany supprime tous les anciens rapports, par exemple un rapport dont Grace a encore besoin.--output out/summary.json. Le parent estout. Résultat mesuré :out/contenaitlast-week.json; ensuite, il contenait seulementsummary.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, seulementsummary.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.
Essayez dans une copie jetable
Section intitulée « Essayez dans une copie jetable »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.
-
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 ~/projectscp -R nextia-learning-labs/C15/snapshots/start ticket-cleaner-throwawaycd ticket-cleaner-throwawaygit init -q && git add -A && git commit -qm "Start"Fenêtre de terminal cd ~\projectsCopy-Item -Recurse nextia-learning-labs\C15\snapshots\start ticket-cleaner-throwawaycd ticket-cleaner-throwawaygit init -q; git add -A; git commit -qm "Start" -
Copie jetable seulement. Vérifiez que vous êtes dedans :
pwddoit se terminer particket-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.patchgit diff --statpython -m pytestSortie ticket_cleaner/cli.py | 9 +++++++++1 file changed, 9 insertions(+)============================== 24 passed in 0.04s ============================== -
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.jsonEnsuite, affichez le contenu du dossier :
ls outsur macOS et Linux,Get-ChildItem outdans PowerShell. Vous voyezlast-week.json. -
Copie jetable seulement.
--cleansupprime 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.jsonls outOutput (the end) 15 rows: 9 valid, 6 rejected.Report: out/summary.jsonsummary.jsonlast-week.jsona 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.
Larkfield : Kwame suit le jeton
Section intitulée « Larkfield : Kwame suit le jeton »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 :
TICKETS_API_TOKEN=demo-token-not-real python -c "from ticket_cleaner.config import load_settings; s = load_settings(); print(s); print(vars(s))"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).
-
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.jsonFenêtre de terminal $env:TICKETS_API_TOKEN = "demo-token-not-real"; $env:LOG_LEVEL = "DEBUG"python -m ticket_cleaner data/tickets.csv --output out/summary.jsonRemove-Item Env:TICKETS_API_TOKEN, Env:LOG_LEVELOutput (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'}
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)oulogger.debug("%s", settings)afficheSettings(tickets_url='https://…/tickets.json', log_level='WARNING').repr=Falsemasque le jeton. - En rouge :
logger.debug("settings: %s", vars(settings))affiche{'tickets_url': '…', 'api_token': 'demo-token-not-real', 'log_level': 'DEBUG'}, carvars()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 :
printf "TICKETS_API_TOKEN=demo-token-not-real\n" > .envls -l .envchmod 600 .envls -l .env-rw-r--r--@ .env-rw-------@ .envrw-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.
-
Remettez la copie jetable à
start.git cleansupprime 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 -dgit clean -fdSortie Would remove out/Removing out/git status --shortn’affiche maintenant rien..envreste, car Git l’ignore, doncgit cleann’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.
Ce qu’Amira fait de la proposition E
Section intitulée « Ce qu’Amira fait de la proposition E »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--outputpointe;--output summary.jsonsupprime le projet, y compris.git. - Secret dans un journal :
logger.debug("settings: %s", vars(settings))affiche le jeton au niveau de débogage, en contournantfield(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.
Quand réviser la sécurité, et à quel coût
Section intitulée « Quand réviser la sécurité, et à quel coût »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?
python -m ticket_cleaner data/tickets.csv --output data/web-form-export.csvExé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).
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
Prédisez d’abord : Les deux réussissent leurs propres tests. Laquelle enfreint un critère d'acceptation, et lequel?
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 summaryCandidat 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.
| Vérification cachée | Candidat 1 | Candidat 2 |
|---|---|---|
| --category billing counts only the billing tickets | réussi | réussi |
| --category billing --category shipping counts both | réussi | réussi |
| --category ' Billing ' (capital letter, spaces) still finds billing | réussi | réussi |
| the report lists the chosen categories, sorted, in small letters | réussi | réussi |
| without --category, the report is exactly as before | réussi | réussi |
| valid_records (9) and rejected (6) still describe the whole file | réussi | échoué |
| an unknown category gives 0 selected and exit code 0 | réussi | réussi |
| --help describes --category | réussi | réussi |
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 :
-
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.patchgit diff --statpython -m pytestruff 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 formattedToutes les vérifications que l’auteur a exécutées réussissent.
-
Vérifiez le critère 5 de la fiche :
valid_recordsetrejectedne changent pas avec--category.Fenêtre de terminal python -m ticket_cleaner data/tickets.csv --category billingSortie 15 rows: 3 valid, 6 rejected.Report: reports/summary.jsonLe rapport contient
"valid_records": 3. La même commande dans votre projet affiche15 rows: 9 valid, 6 rejected.(15 lignes : 9 valides, 6 rejetées) et donne"valid_records": 9. -
Restaurez la copie, puis supprimez-la :
Fenêtre de terminal git restore . && git clean -fdcd ..rm -rf ticket-cleaner-throwawayFenêtre de terminal git restore .; git clean -fdcd ..Remove-Item -Recurse -Force ticket-cleaner-throwawayVé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"]) == 6L’équipe du cours l’a exécuté sur les deux versions :
E assert 3 == 9============================== 1 failed in 0.03s ============================================================= 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.
Vérification du module
Section intitulée « Vérification du module »Vous avez terminé le module quand vous pouvez montrer ces éléments dans votre propre projet :
-
git log --onelinemontre huit commits (enregistrements des modifications) surfeature/category-option. Les deux derniers sontAdd the --category option, after review(ajouter l’option –category après révision) etAdd a checklist for reviewing a generated change(ajouter une liste de vérification pour réviser une modification générée). -
python -m pytestaffiche34 passed(34 tests réussis), etruff format --check .affiche21 files already formatted(21 fichiers déjà formatés). -
python -m ticket_cleaner data/tickets.csv --category billing --category shippingdonne"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érification des connaissances
Section intitulée « Vérification des connaissances »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, etignore_errors=Truemasque tous les problèmes.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Prédisez : 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.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
Cette leçon
- 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.
--cleansupprimait le dossier de--output: avecsummary.json, le projet et.git. Sa ligne de débogage affichait le jeton, carvars()contournefield(repr=False). - Exécutez une modification inconnue seulement dans une copie jetable. Demandez d’abord ce qui sera supprimé :
git clean -navantgit 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--categoryaccepté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