GitHub Copilot peut générer des centaines de cas de test en quelques minutes (des expériences contrôlées montrent que les développeurs terminent 35 % plus vite ), mais il y a un hic : ces tests générés par l'IA ne sont utiles que dans la mesure où vous êtes capable de les suivre, de les organiser et de les relier au reste de votre flux de travail de développement.
Ce guide vous explique comment utiliser GitHub Copilot pour créer rapidement des cas de test, puis vous montre comment les gérer efficacement afin qu'ils ne deviennent pas simplement une pile supplémentaire de fichiers de code orphelins.
Pourquoi les tests unitaires sont-ils importants pour la qualité des logiciels ?
La rédaction de tests unitaires est souvent considérée comme une tâche fastidieuse, mais les ignorer conduit à un code fragile.
Lorsque vous ne disposez pas d'un filet de sécurité sous forme de tests, une petite refonte peut entraîner des défauts de régression, c'est-à-dire des bugs qui perturbent les fonctions existantes et érodent la confiance des utilisateurs. Une étude d'IBM montre que les défauts découverts après la mise en production coûtent 15 fois plus cher à corriger.
Cela crée un cycle dans lequel les développeurs évitent d'améliorer le code par crainte de causer des dysfonctionnements, ce qui entraîne une dette technique croissante.
La génération de tests assistée par l'IA permet de briser ce cycle. Aujourd'hui, 89 % des entreprises testent ou déploient des flux de travail d'IA générative dans le domaine de l'ingénierie qualité et des tests. En utilisant un outil tel que GitHub Copilot pour créer des cas de test, vous pouvez vous concentrer sur l'essentiel : concevoir des tests pertinents et affiner la couverture des cas limites.
Voici pourquoi des tests unitaires réguliers sont payants :
- Prévention des régressions : les bons tests agissent comme des garde-fous, garantissant que les nouvelles fonctionnalités ou les corrections de bugs ne causent pas involontairement d'autres problèmes.
- Documentation vivante : contrairement à la documentation statique qui peut devenir obsolète, les tests unitaires servent d'exemples exécutables du comportement attendu de votre code.
- Confiance dans la refactorisation : lorsque vous disposez d'une couverture de test complète, vous pouvez refactoriser et améliorer votre base de code en toute confiance, sachant que vous serez immédiatement informé si une modification a des conséquences imprévues.
Pour mieux comprendre comment les agents IA transforment le paysage du codage au-delà de la simple génération de tests, regardez cet aperçu des assistants de codage alimentés par l'IA et de leurs capacités :
Comment configurer GitHub Copilot pour la génération de cas de test
Avant de pouvoir commencer à générer des tests, vous devez installer et configurer GitHub Copilot dans votre environnement de développement intégré (IDE). Le processus d’installation est simple et ne prend que quelques minutes, mais le faire correctement garantit que Copilot dispose du contexte nécessaire pour fournir des suggestions pertinentes.
Avant de commencer, vous aurez besoin de quelques éléments :
- Un abonnement GitHub Copilot actif (Individual, Business ou Enterprise)
- Un IDE avec assistance, tel que VS Code, un IDE JetBrains (comme IntelliJ ou PyCharm) ou Neovim.
- Un framework de test tel que pytest, Jest ou JUnit déjà installé dans votre projet.
Installez l'extension GitHub Copilot.
Tout d'abord, vous devez installer l'extension Copilot dans votre IDE. Ce processus est similaire pour la plupart des éditeurs pris en charge.
- Ouvrez la boutique d'extensions de votre IDE. Dans VS Code, il s'agit de l'icône Extensions dans la barre latérale ; dans les IDE JetBrains, vous la trouverez sous Paramètres → Plugins.
- Recherchez « GitHub Copilot ».
- Installez l'extension principale GitHub Copilot et l'extension GitHub Copilot Chat pour profiter pleinement de l'expérience.
- Vous serez invité à redémarrer votre IDE pour achever l'installation.
Après le redémarrage, vous serez invité à vous connecter avec votre compte GitHub. Cette étape permet d'effectuer l'authentification de votre abonnement. Une fois connecté, vous devriez voir une petite icône Copilot dans la barre d'état de votre IDE, confirmant qu'il est actif et prêt à fonctionner.
Configurez votre infrastructure de test
GitHub Copilot génère des tests plus pertinents lorsqu'il comprend l'installation spécifique des tests de votre projet. Pour ce faire, il analyse vos fichiers de test et votre configuration existants afin d'apprendre et de s'adapter aux habitudes de votre équipe.
- Pour les projets Python utilisant pytest : assurez-vous que pytest est installé (pip install pytest). Si vous disposez d'un fichier conftest.py ou de fichiers de test existants (même un seul), Copilot les utilisera comme référence pour générer de nouveaux tests.
- Pour les projets JavaScript/TypeScript utilisant Jest : Copilot recherchera un fichier jest. config. js et votre dépendance Jest dans votre package. json afin de comprendre votre installation.
- Pour les projets Java utilisant JUnit : assurez-vous que vos dépendances JUnit sont correctement définies dans votre fichier pom.xml (pour Maven) ou build.gradle (pour Gradle).
Disposer d'au moins un fichier de test bien rédigé dans votre projet est l'un des meilleurs moyens de guider Copilot. Il reprendra vos conventions de nommage, vos styles d'assertion et la manière dont vous structurez vos tests, ce qui permettra d'obtenir des résultats plus cohérents.
Intégrez Copilot à votre IDE.
Une fois les extensions installées, il est temps de vous familiariser avec l'interface Copilot dans votre IDE. Le panneau Copilot Chat est le principal moyen d'interagir avec l'interface pour la génération de tests.
Vous pouvez ouvrir la fenêtre de discussion à l'aide du raccourci clavier Ctrl+Cmd+I (sur Mac) ou Ctrl+Alt+I (sur Windows/Linux), ou en cliquant sur l'icône Copilot Chat dans la barre d'activité de votre IDE. Ce panneau de discussion est votre centre de commande pour la génération de tests.
Copilot est sensible au contexte, ce qui signifie qu'il lit les fichiers actuellement ouverts, la structure des fichiers de votre projet et tout code que vous avez sélectionné. Pour obtenir les meilleurs résultats, veillez à toujours ouvrir et assurer la visibilité du fichier contenant la fonction ou la classe que vous souhaitez tester dans votre éditeur.
🌟 ClickUp Brain, l'IA contextuelle intégrée à ClickUp, peut rapidement créer un plan de test pour vous. Essayez-le dès aujourd'hui.
Comment écrire des cas de test avec GitHub Copilot
GitHub Copilot vous offre trois méthodes principales pour générer des cas de test : à l'aide du panneau de discussion avec des invites détaillées, à l'aide de commandes slash et à l'aide d'actions intelligentes directement dans votre éditeur. Chaque méthode est adaptée à différentes situations dans votre flux de travail de développement, selon que vous ayez besoin de rapidité ou d'un contrôle précis.
Utilisez les invites Copilot Chat.
L'utilisation de Copilot Chat avec des instructions spécifiques est la méthode la plus efficace pour générer des cas de test. Elle est particulièrement adaptée aux fonctions ou classes complexes pour lesquelles vous devez définir des scénarios spécifiques, simuler des dépendances ou gérer des cas limites délicats.
Voici le flux de travail de base :
- Ouvrez le panneau Copilot pour discuter.
- Dans votre éditeur, sélectionnez la fonction, la classe ou le bloc de code que vous souhaitez tester.
- Rédigez une invite claire et précise dans le panneau de discussion décrivant les tests dont vous avez besoin.
Par exemple, vous pouvez écrire des invitations telles que :
- « Écrivez des tests unitaires pour la fonction sélectionnée couvrant le chemin optimal, les cas limites tels que les entrées vides et la gestion des erreurs pour les données non valides. »
- « Générez des tests pytest pour cette classe et créez des fixtures pour simuler la connexion à la base de données. »
- « Créez des tests Jest pour ce composant React qui simulent les clics des utilisateurs et vérifient les changements d'état. »
Plus vous fournissez de détails dans vos instructions, meilleurs seront les tests générés.
Utilisez des commandes slash telles que /tests.
Lorsque vous devez générer rapidement des tests et que vous n'avez pas besoin de scénarios très spécifiques, la commande slash /tests est votre meilleure alliée. C'est le moyen le plus rapide d'obtenir une base solide pour la couverture des tests.
Pour l'utiliser :
- Ouvrez le panneau Copilot pour discuter.
- Sélectionnez le code que vous souhaitez tester dans votre éditeur.
- Dans la zone de saisie du chat, tapez simplement /tests et appuyez sur Entrée.
Copilot générera immédiatement un ensemble de tests unitaires basés sur la structure et la logique du code que vous avez sélectionné. Il essaiera de couvrir les fonctionnalités principales et certaines entrées courantes. Si les résultats ne sont pas tout à fait corrects, vous pouvez toujours les affiner à l'aide d'une invite de suivi telle que « Ajoutez maintenant un test pour le cas où l'entrée est nulle. »
Utilisez les actions intelligentes de l'éditeur
Lorsque vous souhaitez générer des tests sans interrompre votre flux de travail, vous pouvez utiliser des actions intelligentes directement depuis votre éditeur de code. Cela vous évite d'avoir à passer au panneau de discussion.
- Mettez en surbrillance la fonction ou la classe que vous souhaitez tester.
- Cliquez avec le bouton droit sur la sélection pour ouvrir le menu contextuel.
- Accédez à Générer du code dans le menu contextuel et sélectionnez Générer des tests.
Copilot génère les tests et les affiche généralement dans un nouvel onglet d'éditeur temporaire. Vous pouvez y examiner le code, puis choisir de créer un nouveau fichier de test ou d'ajouter les tests à un fichier existant.
📚 À lire également : Modèles de cas de test pour les tests logiciels
GitHub Copilot vous invite à générer des cas de test
Vos invites sont le volant de GitHub Copilot. Des invites génériques conduisent à des tests génériques, mais des invites bien conçues qui donnent des instructions spécifiques à l'IA permettent d'obtenir des cas de test complets et utiles. La clé est de dire à Copilot non seulement quoi tester, mais aussi comment le tester.
Voici quelques modèles que vous pouvez adapter à différents scénarios :
| Scénario | Modèle de prompt |
|---|---|
| Test unitaire de base | « Écrivez des tests unitaires pour la fonction [nom_fonction] à l'aide de [framework]. Veillez à couvrir les entrées normales, les valeurs limites telles que zéro ou les nombres négatifs, et les entrées non valides telles que null ou undefined. » |
| Classe avec dépendances | « Générer des tests pour la classe [ClassName]. Utiliser [mocking_library] pour créer des simulacres pour les dépendances [DependencyName] et [AnotherDependencyName]. » |
| Fonctions asynchrones | « Créez des tests pour cette fonction asynchrone. Incluez des tests pour le cas de réussite, un cas où la promesse est rejetée et un scénario pour les délais d'attente des requêtes. » |
| Point de terminaison API | « Écrivez des tests d'intégration pour ce point de terminaison API. Couvrez une requête GET avec une réussite, une requête POST avec des données valides, une requête avec un jeton d'authentification manquant et une requête avec des données non valides qui devrait renvoyer une erreur 400. » |
| Validation des données | « Générez des tests pour cette fonction de validation. Incluez un test pour un objet valide, puis ajoutez des tests distincts pour chaque échec de règle de validation afin de vous assurer que les messages d'erreur corrects sont renvoyés. » |
Conseils pour améliorer les invites :
- Soyez explicite au sujet du framework : mentionnez toujours le framework de test (par exemple, pytest, Jest, JUnit) afin de vous assurer que la syntaxe est correcte.
- Définissez vos objectifs de couverture : utilisez des techniques avancées d'invite IA pour demander des types de couverture spécifiques, tels que les « cas limites », la « gestion des erreurs » ou les « tests de limites ».
- Référencez vos propres modèles : si vous disposez d'un bon fichier d'exemple, vous pouvez demander à Copilot de « suivre le modèle de test dans tests/test_user.py ».
- Demandez des assertions spécifiques : au lieu de laisser Copilot deviner, vous pouvez lui demander « d'affirmer qu'une erreur ValueError est générée pour toute entrée non valide ».
📚 À lire également : Les meilleurs outils logiciels d'assurance qualité pour les tests logiciels
Exemples de génération de tests avec GitHub Copilot
Voici comment cela fonctionne dans le travail.
Générez des tests unitaires en Python.
Imaginez que vous ayez une fonction Python qui calcule le prix total des éléments dans un panier, réduction comprise.
Échantillon de fonction à tester :
Invite utilisée : « Écrivez des tests pytest pour calculate_total. Couvrez une liste vide d'éléments, un seul élément, plusieurs éléments, l'application d'une réduction, une réduction de 0 %, une réduction de 100 % et un pourcentage de réduction invalide qui devrait générer une erreur ValueError. »
Résultat du test généré :
Copilot a correctement utilisé pytest. raises pour vérifier l'exception et a couvert les principaux scénarios. Vous pouvez toutefois ajouter des tests pour les prix ou les quantités négatifs à titre de raffinement manuel.
Générez des tests unitaires dans TypeScript avec Jest.
Essayons maintenant une fonction TypeScript qui met en forme le nom d'un utilisateur.
Échantillon de fonction à tester :
Invite utilisée : « Générer des tests Jest pour formatDisplayName. Couvrir un utilisateur avec un prénom et un nom, un utilisateur avec un pseudonyme, un utilisateur avec un prénom vide et un utilisateur avec uniquement un pseudonyme. »
Résultat du test généré :
Les tests générés utilisent les blocs standard describe et it de Jest et gèrent correctement les différents chemins logiques.
Bonnes pratiques pour la génération de tests GitHub Copilot
L'utilisation de Copilot pour la génération de tests permet d'augmenter considérablement la productivité, mais nécessite une surveillance attentive pour garantir la qualité.
- Vérifiez chaque test : c'est la règle d'or. Copilot ne comprend pas votre logique métier, il peut donc générer un test qui réussit mais qui vérifie la mauvaise chose. Lisez toujours le code généré et demandez-vous : « Est-ce que cela vérifie réellement le comportement correct ? »
- Vérifiez manuellement la couverture des cas limites : Copilot est efficace pour repérer les cas limites courants tels que les entrées nulles ou les chaînes vides, mais il peut en manquer certains spécifiques à un domaine. Pour une application de commerce électronique, a-t-il testé ce qui se passe lorsque le total du panier correspond exactement au minimum requis pour bénéficier de la livraison gratuite ? Vous restez l'expert.
- Maintenez des conventions de nommage cohérentes : les noms de tests générés par l'IA peuvent parfois être génériques. Prenez le temps de les renommer pour qu'ils correspondent au style de votre équipe. Un nom descriptif tel que test_login_fails_with_incorrect_password est bien plus utile que test_login_2.
- Exécutez les tests immédiatement : ne laissez pas les tests générés inutilisés. Exécutez-les immédiatement pour détecter les erreurs de syntaxe ou les assertions manifestement erronées avant la validation du code.
- Intégrez-le à CI/CD : ajoutez les tests générés à votre pipeline d'intégration continue. Les tests qui ne s'exécutent que localement fournissent une valeur limitée.
- Méfiez-vous des tests instables : parfois, l'IA peut générer des tests « instables », qui réussissent parfois et échouent d'autres fois. Cela se produit souvent avec les tests impliquant des horodatages ou des données aléatoires. Remplacez-les toujours par des valeurs déterministes et prévisibles.
📮ClickUp Insight : Nos sondages montrent que si 34 % des utilisateurs font entièrement confiance aux systèmes d'IA, un groupe légèrement plus important (38 %) adopte une approche « faire confiance mais vérifier ». Un outil autonome qui ne connaît pas votre contexte de travail présente souvent un risque plus élevé de générer des réponses inexactes ou insatisfaisantes.
C'est pourquoi nous avons créé ClickUp Brain, l'IA qui relie la gestion de projet, la gestion des connaissances et la collaboration au sein de votre environnement de travail et des outils tiers intégrés. Obtenez des réponses contextuelles sans avoir à activer/désactiver un onglet et bénéficiez d'une efficacité de travail 2 à 3 fois supérieure, tout comme nos clients chez Seequent.
Limites de l'utilisation de GitHub Copilot pour la génération de cas de test
Bien que GitHub Copilot soit un formidable outil pour booster la productivité, il ne s'agit pas d'une solution miracle pour les tests logiciels. Il est essentiel de connaître ses limites pour l'utiliser efficacement et éviter les pièges courants. Il s'agit d'un « copilote », pas d'un pilote : c'est toujours vous qui êtes responsable du plan de vol.
Sa plus grande limite est son manque de contexte métier. Copilot analyse la structure de votre code, mais il n'a aucune idée de ce que votre application est censée faire pour vos utilisateurs. Il ne peut pas savoir qu'un utilisateur « premium » doit avoir accès à certaines fonctionnalités alors qu'un utilisateur « basique » ne doit pas y avoir accès, à moins que cette logique ne soit explicitement claire dans le code qu'il lit.
Voici quelques autres contraintes clés à garder à l'esprit :
- Il peut passer à côté de cas limites critiques spécifiques à un domaine : Copilot est très efficace pour trouver des cas limites généraux, mais il ne connaîtra pas les cas particuliers à votre secteur d'activité, comme un calcul financier qui doit traiter différemment les années bissextiles.
- Il n'a pas accès aux systèmes externes : Copilot ne peut pas générer de tests d'intégration significatifs pour votre base de données ou une API tierce, car il ne peut pas effectuer de connexions. Il peut créer le code, mais vous devrez remplir les détails.
- Cela peut donner un faux sentiment de confiance : voir une couverture de test de 100 % peut être très gratifiant, mais si les tests vérifient les mauvaises choses, ce nombre n'a aucun sens. C'est pourquoi la révision humaine est si importante.
- Limites de la fenêtre de contexte : les fichiers très volumineux ou les hiérarchies de classes complexes peuvent dépasser la fenêtre de contexte de Copilot, ce qui peut entraîner des suggestions incomplètes ou génériques.
📚 À lire également : Comment utiliser GitHub Copilot pour le développement backend
Comment créer et gérer des cas de test dans ClickUp
La génération de cas de test avec GitHub Copilot ne représente que la moitié du flux de travail. Une fois les tests créés, les équipes doivent encore les suivre, les lier aux exigences et gérer leur exécution tout au long des sprints et des versions.
ClickUp fournit un environnement de travail centralisé où les cas de test générés par l'IA peuvent coexister avec les tâches de développement, les bugs et les plans de sprint, afin que les tests ne restent pas confinés dans des IDE individuels.
ClickUp agit comme un environnement de travail IA convergent, regroupant la gestion de projet, la documentation et la communication d'équipe dans un seul système. Pour les équipes logicielles, cela signifie que la gestion des cas de test n'est plus un outil ou un tableur distinct.
Les tests, les exigences, les demandes de tirage et les discussions sur les versions restent tous connectés, ce qui réduit la dispersion du contexte et fait de l'assurance qualité un élément essentiel du flux de travail de livraison.
Le modèle de cas de test de ClickUp est conçu pour vous aider au suivi de la progression des cas de test. Il facilite les tâches suivantes :
- Examinez les résultats des tests et prenez des décisions fondées sur les données pour corriger les bugs.
- Élaborez des plans de test personnalisés pour chaque projet.
- Organisez et hiérarchisez les cas de test pour une efficacité maximale.
Commencez par créer une liste ClickUp dédiée qui servira de référentiel pour vos cas de test. Chaque cas de test, qu'il soit généré par l'IA ou rédigé manuellement, devient une tâche.
Enrichissez chaque cas de test avec des métadonnées cruciales à l'aide des champs personnalisés ClickUp pour suivre exactement ce qui importe à votre équipe.
- Type de test : menu déroulant pour les tests unitaires, d'intégration, de bout en bout ou manuels.
- Statut d'automatisation : statut indiquant si le test est automatisé ou non.
- Priorité : élevée, moyenne ou faible
- Date de la dernière exécution : champ de date permettant de suivre la date à laquelle le test a été exécuté pour la dernière fois.
Suivez l'ensemble du cycle de vie de vos tests grâce aux statuts personnalisés de ClickUp en créant un flux de travail qui fait passer les tests de « Non exécuté » à « Réussi », « Échoué » ou « Bloqué ». Cela permet à tous les membres de l'équipe, des développeurs aux chefs de produit, de bénéficier d'une visibilité instantanée sur la progression de l'exécution des tests.
Avec ClickUp Relationships, les tâches de test peuvent être directement liées aux récits d'utilisateurs, aux fonctionnalités ou aux épopées. Si un test échoue, vous pouvez créer une tâche de rapport de bogue et la relier à la fois au test échoué et au récit d'origine, créant ainsi une chaîne de traçabilité complète.
Rédigez des rapports de bogues en quelques secondes en pointant ClickUp Brain vers une tâche de cas de test ayant échoué. Comme il dispose du contexte de l'ensemble de votre environnement de travail, il peut extraire des détails de l'histoire utilisateur liée et du cas de test lui-même.
🌟 Le modèle de rapport de test de ClickUp vous permet de créer des rapports plus rapidement tout en vous assurant d'identifier et de résoudre les problèmes qui doivent être améliorés.
Mais ce n'est pas tout ce que vous pouvez faire. Vous savez toutes ces tâches fastidieuses dont nous avons parlé, ces tâches ennuyeuses et répétitives qui accompagnent toujours les tests ? Vous pouvez les automatiser à l'aide de ClickUp Automations.
Configurez des règles telles que « Lorsque le statut d'un cas de test passe à Échec, créez automatiquement une nouvelle tâche dans la liste des bogues et attribuez-la au développeur principal. »
En intégrant GitHub à ClickUp, les tâches de test peuvent être liées aux validations et aux demandes de tirage. Lorsque des modifications de code sont fusionnées, les tâches de test associées sont automatiquement mises à jour, ce qui permet aux équipes d'assurance qualité, aux développeurs et aux responsables de publication de rester informés des changements et des éléments à retester.
Les tableaux de bord ClickUp vous permettent de suivre en temps réel la progression des tests, de visualiser le nombre de bogues, l'exécution des cas de test, et bien plus encore.
Ensemble, ce flux de travail comble le fossé entre les tests générés par l'IA dans GitHub Copilot et la gestion des cas de test à l'échelle de l'équipe dans ClickUp, offrant aux équipes un système unique pour planifier, suivre, automatiser et améliorer leur processus d'assurance qualité sans coordination manuelle constante.
Regardez cette vidéo pour obtenir des conseils sur la création d'un flux de travail efficace de gestion des versions :
Simplifiez la gestion des cas de test avec ClickUp
Les tests générés par l'IA ne sont plus des artefacts isolés ; ils font désormais partie intégrante de votre processus de développement, avec une visibilité, des traces et une exploitation possibles pour toute l'équipe.
GitHub Copilot génère rapidement des cas de test, mais la rapidité seule ne garantit pas la qualité. Sans une propriété claire, une traçabilité des exigences et une visibilité sur l'ensemble des Sprints, même les tests bien rédigés peuvent devenir obsolètes ou être négligés. C'est là qu'un système d'enregistrement prend toute son importance.
En gérant les cas de test dans ClickUp, les équipes transforment les résultats générés par l'IA en un flux de travail d'assurance qualité reproductible, qui relie les tests aux exigences, aux modifications de code et aux échéanciers de publication. Au lieu de jongler entre différents outils et mises à jour manuelles, les équipes d'assurance qualité et d'ingénierie travaillent à partir d'un environnement de travail partagé et contextuel. Il en résulte non seulement davantage de tests, mais aussi une plus grande confiance dans ce qui est livré et pourquoi.
Prêt à gérer vos cas de test parallèlement à vos sprints et à vos versions ? Commencez dès aujourd'hui avec ClickUp, gratuitement.
Foire aux questions
Oui, Copilot peut analyser la structure et la logique du code hérité pour générer une base de référence de tests. Cependant, ces tests nécessiteront probablement une révision et un affinement manuels importants, car l'IA n'aura pas de contexte sur les comportements non documentés ou les règles commerciales historiques.
La précision syntaxique est très élevée, mais la précision logique dépend de la clarté de votre code et de la spécificité de vos invitations. Vérifiez toujours les assertions pour vous assurer qu'elles vérifient des exigences commerciales significatives, et ne se contentent pas de confirmer l'implémentation actuelle (et potentiellement défaillante).
Oui, Copilot offre une excellente assistance pour pytest, unittest et d'autres frameworks de test Python populaires. Il est capable de reconnaître et de reproduire les modèles existants dans votre projet, tels que l'utilisation de fixtures ou de tests paramétrés.
Les équipes efficaces utilisent une plateforme centralisée de gestion de projet pour gérer leurs suites de tests. En suivant chaque cas de test comme une tâche avec des métadonnées personnalisées pour le statut et la priorité, elles obtiennent une visibilité sur la couverture et les résultats d'exécution, établissant ainsi une connexion directe entre le processus d'assurance qualité et la planification des sprints et le suivi des bogues.