Augmentation de la couverture des tests dans votre entreprise avec GitHub Copilot

Comprendre les fonctionnalités, permettre aux développeurs et mesurer l’impact de Copilot.

Qui peut utiliser cette fonctionnalité ?

GitHub Copilot Business or GitHub Copilot Enterprise

Dans cet article

Le guide est inspiré par Playbook pour la réussite des systèmes d'ingénierie (ESSP) de GitHub, qui recommande des stratégies et des indicateurs pour améliorer les systèmes d'ingénierie.

Si vous démarrez un déploiement de Copilot, nous vous recommandons de définir vos objectifs, de planifier votre déploiement en conséquence et de communiquer clairement les objectifs au personnel. Consultez Atteindre les objectifs d’ingénierie de votre entreprise avec GitHub Copilot.

1. Identifier les obstacles au succès

La première étape recommandée par l’ESSP consiste à développer une compréhension claire des obstacles empêchant les améliorations de votre entreprise. En comprenant votre situation actuelle, vos objectifs futurs et les obstacles qui vous empêchent de progresser, vous pouvez garantir que les changements apportés seront ciblés et efficaces.

De nombreuses équipes logicielles sont confrontées à des défis persistants en matière de maintien du code de haute qualité en raison d’une faible couverture des tests unitaires. Dans les environnements de développement rapides, l’écriture de tests est souvent considérée comme chronophage ou non essentielle, en particulier lorsque les équipes sont sous pression pour fournir rapidement des fonctionnalités.

Par conséquent, les bogues critiques peuvent être découverts en retard dans le cycle de vie du développement, souvent dans les environnements intermédiaires ou de production.

Cela conduit à une chaîne de résultats négatifs :

  • taux de bogues plus élevés et problèmes signalés par le client
  • augmentation du coût de correction des bogues après le déploiement
  • la confiance des développeurs réduite dans la stabilité de leur code
  • cycles de publication plus lents en raison du débogage réactif et de la mise à jour corrective

Dans les systèmes hérités, la couverture des tests peut être encore plus difficile à traiter en raison de dépendances complexes ou de code mal documenté. Les développeurs peuvent ne pas connaître les bases de code plus anciennes ou les frameworks de test en général, ce qui complique davantage le problème.

L’amélioration de la couverture des tests est une bonne pratique reconnue, mais elle nécessite du temps et de l’expertise que de nombreuses équipes luttent pour allouer.

2. Évaluer vos options

L’étape suivante consiste à évaluer et à accepter des solutions pour résoudre les obstacles que vous avez identifiés à l’étape 1. Dans ce guide, nous allons nous concentrer sur l’impact que GitHub Copilot peut avoir sur l’objectif que vous avez identifié. N’oubliez pas que les lancements réussis d’un nouvel outil nécessitent également des modifications apportées à la culture et aux processus.

Vous allez exécuter des essais de nouveaux outils et processus avec des groupes pilotes pour recueillir des commentaires et mesurer le succès. Pour les ressources de formation et les indicateurs de performance à utiliser pendant les essais, vous pouvez consulter le 3. Sections Implémentez les modifications et Indicateurs de performance à surveiller.

Inscrivez-vous à Copilot

Comment Copilot peut vous aider

GitHub Copilot peut considérablement accélérer et simplifier le processus de rédaction des tests unitaires. En comprenant le code et le contexte environnants, Copilot peut suggérer des fonctions de test qui correspondent à la structure et à la logique du code testé.

Les fonctionnalités de Copilot sont utiles dans de nombreux cas :

  • Lorsque les développeurs écrivent de nouvelles fonctions, Copilot peut automatiquement suggérer les cas de test correspondants en ligne.
  • Lors de la refonte d'un code hérité, Copilot peut aider à générer un échafaudage de test afin d'éviter les régressions.
  • Pour les modules non testés, les développeurs peuvent demander à Copilot de générer des cas de test pertinents, même lorsque la couverture des tests est insuffisante ou incohérente.

En rendant les tests unitaires plus faciles, plus rapides et moins manuels, Copilot réduit les frictions susceptibles d'entraîner des lacunes dans la couverture des tests et aide les équipes à adopter une approche axée sur la qualité.

Cas d’utilisation

  • Génération de tests en ligne: Les développeurs peuvent demander à Copilot de générer des tests pour une fonction ou un module spécifique sans changer de contexte.
  • Meilleure couverture des cas limites: En générant Copilot pour les scénarios limites (tels que les entrées nulles, les listes vides ou les états non valides), les développeurs peuvent rapidement couvrir davantage de branches logiques.
  • Intégration accélérée: Les nouveaux membres de l'équipe peuvent utiliser Copilot pour comprendre comment une fonction est censée se comporter en examinant les cas de test générés.
  • Assistance avec CI/CD: Copilot peut vous suggérer comment intégrer des tests dans votre pipeline de compilation, garantissant ainsi que les améliorations apportées à la couverture soutiennent directement les contrôles qualité.

Considérations culturelles

En plus de votre déploiement de GitHub Copilot, vous devez également traiter tous les facteurs sociaux ou culturels qui pourraient vous empêcher d’atteindre vos objectifs.

Les exemples suivants sont tirés de la section « Anti-modèles » de l’ESSP.

  • Teams peut s’appuyer sur des tests manuels ou des tests automatisés insuffisants. Cela peut être dû à des contraintes de ressources pour l’automatisation ou à un manque d’expérience avec les outils de test modernes.
  • Teams peut attendre trop longtemps pour libérer, le déploiement de lots volumineux de code à la fois, ce qui rend les bogues et les régressions plus difficiles à détecter. Cela peut être dû à un manque de maturité du pipeline CI/CD, à des exigences de conformité strictes ou à des cycles de révision longs entre la demande de tirage et le déploiement.

3. Implémenter des modifications

Une fois identifiée la bonne approche pour surmonter vos obstacles, vous mettrez en œuvre les solutions que vous avez identifiées. Pour un déploiement réussi d’un nouvel outil ou d’un processus, il est important d’attribuer la propriété à chaque partie du déploiement, de communiquer de manière transparente sur vos objectifs, de fournir une formation efficace et de mesurer vos résultats.

Cette section fournit des exemples de scénarios, de bonnes pratiques et de ressources pour les développeurs. Nous vous recommandons d’utiliser cette section pour planifier des sessions de communication et de formation pour aider les employés à utiliser Copilot d’une manière qui s’aligne sur votre objectif.

Générer des tests en ligne

  1. Dans VS Code, sélectionnez la fonction que vous souhaitez tester et saisissez Copilot.: Generate a unit test for this code.
  2. Copilot génère un test en ligne ou dans un fichier de test séparé, selon le langage et la structure.
  3. Examinez, affinez et acceptez la suggestion.

Couvrir les cas de bord

  1. Après avoir rédigé un test, demandez Copilot: What are some edge cases I should test for this function?

    Ou : Write test cases for when the input is null or empty.

  2. Copilot suggère des cas de test supplémentaires pour couvrir les conditions limites.

  3. Passez en revue les tests et incorporez-les dans votre suite de tests.

Comprendre les nouveaux codes

  1. Sélectionnez une fonction héritée et demandez Copilot : Explain what this function does and generate a test to validate it.
  2. Copilot explique l'objectif de la fonction et suggère des cas de test correspondants.
  3. Examinez les cas de test pour comprendre le comportement attendu et générer rapidement le contexte.

Obtenir de l'aide pour CI/CD

  1. Passez en revue vos cas de test et validez-les dans le codebase.
  2. Demandez Copilot : Where should I place this test if I want it to run in CI?
  3. En fonction de la structure du code source, Copilot suggérera où placer les fichiers de test et comment mettre à jour les configurations du pipeline.

Bonnes pratiques pour les développeurs

Les développeurs doivent :

  • Utilisez des commentaires descriptifs ou des invites lorsque vous discutez avec Copilot. Par exemple : Generate unit tests for a function that calculates discounts based on user type and purchase amount.
  • Utilisez Copilot pour explorer la couverture logique. Par exemple : What branches or conditions does this function have that should be tested?
  • Explorez différentes techniques d’invite et comparez les résultats de différents modèles IA.

Les développeurs ne doivent pas :

  • Acceptez les tests générés sans passer en revue la logique. Assurez-vous que les tests reflètent les exigences réelles et gèrent les entrées et sorties réalistes.
  • Ignorez l’assertion du comportement de périphérie. Si vous testez uniquement les « chemins heureux », vous risquez des régressions manquantes.
  • Fiez-vous à Copilot pour deviner les règles commerciales non documentées. Fournissez toujours le contexte par le biais d’invites ou de commentaires.
  • Considérez Copilot comme un substitut aux révisions de code humaines. Copilot accélère le processus, mais vous devez toujours faire preuve de discernement technique.

Ressources pour les développeurs

Métriques à surveiller

Pour évaluer les essais de nouveaux outils et vous assurer que vos déploiements complets offrent des améliorations cohérentes, vous devez surveiller les résultats et apporter des ajustements si nécessaire. En général, nous recommandons de prendre en compte les domaines clés que sont la qualité, la rapidité et la satisfaction des développeurs, ainsi que la manière dont ces domaines contribuent ensemble aux résultats commerciaux.

Voici quelques métriques que nous vous recommandons d’examiner pour évaluer l’impact de Copilot' sur cet objectif spécifique.

  • Couverture des tests: Suivez l'augmentation de la couverture des lignes et des branches après l'adoption de Copilot. Si possible, examinez les rapports de couverture des tests à partir de vos pipelines CI.
  • taux de bogues après le déploiement: moins de bogues doivent être signalés dans les environnements de production.
  • confiance des développeurs: utilisez des enquêtes ou des rétrospectives pour évaluer la confiance des développeurs lors de l’expédition du nouveau code.
  • temps d’écriture de tests: réduction du temps consacré à la création de tests unitaires.