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 rencontrent des difficultés persistantes pour maintenir un code de haute qualité en raison d'une faible couverture des tests unitaires. Dans les environnements de développement au rythme soutenu, l'écriture de tests est souvent perçue comme chronophage ou non essentielle, en particulier lorsque les équipes sont sous pression pour livrer rapidement des fonctionnalités.

Par conséquent, des bugs critiques peuvent être découverts tard dans le cycle de vie du développement, souvent dans des environnements de préproduction ou de production.

Cela entraîne une série de conséquences négatives :

  • Taux de bugs plus élevés et problèmes signalés par les clients
  • Coût accru de la correction des bugs après le déploiement
  • Confiance réduite des développeurs dans la stabilité de leur code
  • Cycles de publication plus lents en raison du débogage réactif et de l'application de correctifs

Dans les systèmes hérités, la couverture de tests peut être encore plus difficile à améliorer en raison de dépendances complexes ou d'un code mal documenté. Les développeurs peuvent manquer de familiarité avec les bases de code plus anciennes ou avec les frameworks de test en général, ce qui aggrave encore le problème.

L'amélioration de la couverture de tests est une bonne pratique reconnue, mais elle nécessite du temps et une expertise que de nombreuses équipes peinent à mobiliser.

2. Évaluez 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é. Les déploiements réussis d’un nouvel outil nécessitent également des modifications apportées à la culture et aux processus.

Exécuter des essais de nouveaux outils et processus avec des groupes pilotes pour recueillir des commentaires et mesurer la réussite. Pour connaître les ressources et les métriques d’apprentissage à utiliser pendant les essais, consultez 3. Implémentez les modifications et les métriques pour surveiller les sections.

          <a href="https://github.com/github-copilot/purchase?ref_product=copilot&ref_type=trial&ref_style=button&ref_plan=enterprise" target="_blank" class="btn btn-primary mt-3 mr-3 no-underline">
          <span>S’inscrire Copilot</span><svg version="1.1" width="16" height="16" viewBox="0 0 16 16" class="octicon octicon-link-external" aria-label="link external icon" role="img"><path d="M3.75 2h3.5a.75.75 0 0 1 0 1.5h-3.5a.25.25 0 0 0-.25.25v8.5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-3.5a.75.75 0 0 1 1.5 0v3.5A1.75 1.75 0 0 1 12.25 14h-8.5A1.75 1.75 0 0 1 2 12.25v-8.5C2 2.784 2.784 2 3.75 2Zm6.854-1h4.146a.25.25 0 0 1 .25.25v4.146a.25.25 0 0 1-.427.177L13.03 4.03 9.28 7.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.75-3.75-1.543-1.543A.25.25 0 0 1 10.604 1Z"></path></svg></a>

Comment Copilot peut aider

          GitHub Copilot peut accélérer et simplifier considérablement le processus d’écriture de tests unitaires. En comprenant le code et le contexte environnants, Copilot vous pouvez suggérer des fonctions de test qui correspondent à la structure et à la logique du code en cours de test.

          Copilotpossède des fonctionnalités utiles dans plusieurs scénarios :
  • Lorsque les développeurs écrivent de nouvelles fonctions, Copilot peuvent suggérer automatiquement des cas de test correspondants inline.
  • Lors de la refactorisation du code hérité, Copilot peut aider à générer un échafaudage de test pour empêcher les régressions.
  • Pour les modules non testés, les développeurs peuvent demander Copilot de générer des cas de test significatifs, même lorsque la couverture des tests est manquante ou incohérente.

En rendant les tests unitaires plus faciles, plus rapides et moins manuels, Copilot réduit les frictions qui peuvent entraîner des lacunes dans la couverture des tests et aide les équipes à adopter une mentalité de qualité première.

Cas d'utilisation

  • Génération de test inline : 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 de cas de périphérie : en demandant des Copilot scénarios de périphérie (par exemple, des entrées null, des listes vides ou des états non valides), les développeurs peuvent rapidement couvrir davantage de branches de logique.
  • 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 suggérer comment intégrer des tests dans votre pipeline de build, en garantissant que les améliorations de la couverture soutiennent directement les portes de qualité.

Considérations culturelles

En plus de votre déploiement de GitHub Copilot, résolvez 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.

  • Les équipes peuvent s'appuyer sur des tests manuels ou sur des tests automatisés insuffisants. Cela peut être dû à des contraintes de ressources pour l'automatisation ou à un manque d'expérience avec des outils de test modernes.
  • Les équipes peuvent attendre trop longtemps pour publier, en déployant de gros lots de code d'un seul coup, ce qui rend plus difficiles la détection des bugs et des régressions. Cela peut être dû à un manque de maturité du pipeline CI/CD, à des exigences de conformité strictes ou à de longs cycles de révision entre la PR et le déploiement.

3. Mettre en œuvre des changements

Lorsque vous avez identifié la bonne approche pour surmonter vos obstacles, mettez à l’échelle les solutions que vous avez identifiées. Pour un déploiement réussi d’un nouvel outil ou d’un processus, attribuez la propriété à chaque partie du déploiement, communiquez de manière transparente sur vos objectifs, fournissez une formation efficace et mesurez vos résultats.

Cette section fournit des exemples de scénarios, des bonnes pratiques et des ressources pour les développeurs. Utilisez 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 inviter Copilot: Generate a unit test for this code.
  2.        Copilot génère un test inline ou dans un fichier de test distinct, en fonction de la langue et de la structure.
  3. Examinez, affinez et acceptez la suggestion.

Couvrir les cas limites

  1. Après avoir écrit 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 de limite.

  3. Examinez les tests et intégrez-les à votre suite de tests.

Comprendre le nouveau code

  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 les cas de test correspondants.
  3. Consultez les cas de test pour comprendre le comportement attendu et établir rapidement le contexte.

Obtenir de l'aide pour la CI/CD

  1. Examinez vos cas de test et validez-les dans la base de code.
  2. Ask Copilot :Where should I place this test if I want it to run in CI?
  3. En fonction de la structure du codebase, Copilot vous suggérerez où placer des fichiers de test et comment mettre à jour les configurations de pipeline.

Bonnes pratiques pour les développeurs

Les développeurs doivent :

  • Utilisez des commentaires descriptifs ou des invites lors de la conversation 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?
  • Explorer différentes techniques de prompt et comparer les résultats provenant de différents modèles d'IA.

Les développeurs ne doivent pas :

  • Accepter des tests générés sans examiner la logique. S'assurer que les tests reflètent les exigences réelles et gèrent des entrées et sorties réalistes.
  • Sauter l'assertion du comportement en limite. Si vous ne testez que les « cas nominaux », vous risquez de passer à côté de régressions.
  • S'appuyer sur Copilot pour deviner les règles non documentées de l'entreprise. Fournir toujours du contexte via des prompts ou des commentaires.
  • Traitez Copilot comme un substitut pour les révisions de code humain. Copilot accélère le processus, mais vous devez toujours appliquer un jugement d’ingénierie.

Ressources pour les développeurs

Mesures à surveiller

Pour évaluer les essais de nouveaux outils et vous assurer que vos déploiements complets offrent des améliorations cohérentes, surveillez les résultats et apportez des ajustements si nécessaire. Nous vous recommandons de prendre en compte les zones clés de la qualité, de la vélocité et du bonheur des développeurs, et la façon dont ces zones se réunissent pour contribuer aux résultats métier.

Voici quelques métriques permettant d’évaluer l'impact de Copilot sur cet objectif spécifique.

  • Couverture des tests : effectuez le suivi des augmentations de couverture de ligne et de branche après Copilot l’adoption. Si possible, examinez les rapports de couverture de tests issus de vos pipelines CI.
  • Taux de bugs après le déploiement : Moins de bugs devraient être signalés dans les environnements de production.
  • Confiance des développeurs : Utilisez des sondages ou des rétrospectives pour évaluer le niveau de confiance des développeurs lorsqu'ils livrent du nouveau code.
  • Temps d'écriture des tests : Mesurez la réduction du temps consacré à la création de tests unitaires.