Création de test assistée par l’IA avec GitHub Copilot (version préliminaire)

La création de plans de test complets pour les applications Power Platform peut prendre beaucoup de temps, en particulier pour les scénarios complexes. Les outils de création assistés par l’IA GitHub Copilot peuvent accélérer considérablement ce processus en générant des modèles de test, en suggérant des cas de test et en automatisant la création de code standard.

Ce guide explique comment utiliser GitHub Copilot avec les solutions de contrôle de code source Power Platform pour créer efficacement des plans de test Test Engine.

Prérequis

Avant de commencer, assurez-vous d’avoir :

• Visual Studio Code installé
• Un abonnement GitHub Copilot
• Extension GitHub Copilot Chat pour VS Code
• Power Platform CLI installé
• Une solution Power Platform contrôlée par la source

Configuration de votre environnement de création de tests

Pour maximiser l’efficacité de la création de tests assistée par l’IA, combinez ces outils dans un flux de travail structuré :

1. Récupérez vos fichiers sources
   • Clonez votre environnement ou votre solution Power Platform à partir du contrôle de code source
   • Exportez votre solution et décompressez-la de Power Platform avec les fichiers à l’aide de pac solution export et pac solution unpack
2. Initialiser un référentiel git pour le contrôle de version (si ce n’est pas déjà fait)
3. Créez un dossier de test dédié dans votre référentiel de solutions
4. Ouvrez le dossier de la solution dans Visual Studio Code

Utilisez GitHub Copilot pour la création de tests

GitHub Copilot peut vous aider à générer divers composants de test en fonction de votre solution contrôlée par la source. Voici comment utiliser efficacement ses fonctionnalités :

Utilisation d’un exemple de documentation comme contexte

Le catalogue d’exemples Test Engine constitue une source importante de documents de référence pour GitHub Copilot. Vous pouvez aider Copilot à générer des tests de meilleure qualité en :

• Inclure le fichier samples.md dans votre espace de travail
• Référencer des exemples spécifiques dans vos invites
• Fournir des liens vers des exemples de référentiels GitHub

Par exemple, vous pourriez :

• Ouvrez à la fois votre code d’application et le fichier samples.md dans VS Code
• Demander à Copilot de créer des tests « similaires à l’exemple ButtonClicker » ou « en utilisant des modèles de l’exemple Dataverse »
• Référencez des fonctionnalités spécifiques à partir d’exemples qui correspondent à vos besoins de test

Cette approche aide Copilot à comprendre les modèles Power Platform Test Engine et à générer des tests plus précis.

Utilisation de GitHub Copilot dans le Mode Assistant

Visual Studio Code GitHub Copilot Chat offre un Mode Assistant qui peut aider à générer des tests basés sur les fichiers de votre solution. Ce mode permet à Copilot d’accéder au contexte de votre projet et de le comprendre plus en profondeur.

Pour utiliser le mode Agent pour la génération de tests :

1. Dans VS Code, ouvrez GitHub Copilot Chat (Ctrl+Maj+I)
2. Sélectionnez Assistant dans le sélecteur de mode Copilot
3. Créez une invite détaillée sur le test que vous souhaitez créer

Exemples d’invites pour la génération de tests

Essayez d’utiliser des invites comme celles-ci pour la génération de tests :

Comprendre les composants de test générés

Quand GitHub Copilot génère un test, il crée généralement les composants suivants :

• Plan de test YAML : définit la structure de test, l’URL de l’application et les étapes de test
• Étapes de test Power Fx : contient la logique de test à l’aide d’expressions Power Fx
• config.json : Configuration des paramètres d’exécution des tests
• RunTest.ps1 : script PowerShell pour exécuter le test

Exemple : Structure de test générée

MyAppTests/
├── MyAppTest.fx.yaml     # Power Fx test steps
├── MyAppTest.yml         # Test plan definition
├── config.json           # Test configuration
└── RunTest.ps1           # Test execution script

Meilleures pratiques pour la création de tests assistée par l’IA

Tenez compte des sections suivantes pour tirer le meilleur parti de la création de tests avec GitHub Copilot Test Engine.

Fournissez un contexte clair dans vos invites

Soyez précis sur ce que vous souhaitez tester et incluez des références à :

• Les fichiers exacts à tester
• Exemples de tests à utiliser comme modèles
• Scénarios de test spécifiques que vous souhaitez couvrir
• Toutes les exigences en matière d’authentification ou d’environnement

Utilisation d’exemples Test Engine pour le contexte

La documentation samples.md répertorie tous les exemples disponibles dans le référentiel Test Engine, ce qui peut être une excellente référence lors de la création d’invites pour GitHub Copilot. Par exemple, lorsque vous testez une application canevas avec des boutons, vous pouvez vous référer à l’exemple Button Clicker :

Invite :
Générez un test pour mon application canevas sur ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml en utilisant l’exemple ButtonClicker de https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker comme référence. Le test doit :
1. Vérifier que le bouton de mon compteur incrémente une valeur à l’écran
2. Conditions de délimitation du test (par exemple, valeur maximale)
3. Inclure les hooks de cycle de vie OnTestCaseStart et OnTestCaseComplete
4. Générer le config.json avec les variables d’environnement appropriées

Cette approche aide Copilot à comprendre la structure du test et génère des tests plus précis et contextuellement pertinents basés sur des exemples éprouvés.

Utiliser des solutions contrôlées par la source comme contexte

Copilot fonctionne mieux lorsqu’il peut analyser la structure de votre solution. Utilisez le contrôle de code source pour les solutions Power Platform afin de fournir ce contexte. Ce contexte permet à Copilot de :

• Comprendre la structure de votre application
• Identifier les noms et les propriétés des contrôles
• Générez des étapes de test plus précises
• Référencer les chemins d’accès de fichier corrects

Examiner et affiner les tests générés

Bien que les tests générés par l’IA constituent un excellent point de départ, toujours :

• Vérifiez que les références de contrôle correspondent à votre application
• Ajouter des assertions pour les fonctionnalités critiques pour l’entreprise
• S’assurer que les cas limites sont correctement traités
• Valider la configuration d’authentification

Combiner avec l’expertise manuelle

Pour les scénarios de test complexes, utilisez GitHub Copilot pour :

• Générer le cadre et la structure de test
• Créer des modèles de validation standard
• Suggérer des cas limites à prendre en compte

Ensuite, complétez avec votre expertise du domaine pour :

• Règles de validation spécifiques à l’entreprise
• Considérations environnementales
• Données de test spécialisées

Modèles courants de génération de tests

Cette section contient quelques modèles de génération de tests courants :

Test d’applications canevas

Pour les applications canevas, utilisez des invites qui référencent le fichier App.fx.yaml dans votre solution contrôlée par la source :

Invite :
Générer un test pour mon application canevas à l’adresse ./SolutionPackage/src/CanvasApps/src/MyExpenseApp/Src/App.fx.yaml qui valide le processus de soumission des dépenses. Le test doit renseigner les champs de dépenses, envoyer le formulaire et vérifier que le message de confirmation s’affiche.

Tester des applications pilotées par modèle

Pour les applications pilotées par modèle, concentrez-vous sur la navigation dans les entités, les interactions de formulaire et les règles métier :

Invite :
Créer un test pour mon application pilotée par modèle qui teste le formulaire de l’entité Compte. Le test doit créer un enregistrement de compte, valider les champs obligatoires et vérifier que les règles métier pour le calcul de la limite de crédit fonctionnent correctement.

Tester des extensions Dataverse

Pour les tests Dataverse, mettez l’accent sur la validation des opérations de données et de la logique métier :

Invite :
Génère un test Dataverse qui valide les plug-ins personnalisés de ma solution. Le test doit créer des enregistrements de test, déclencher l’exécution du plug-in et vérifier que les transformations de données attendues se sont produites.

Invites de test spécifiques à l’exemple

Pour obtenir la génération de tests la plus précise, référencez des exemples spécifiques du catalogue d’exemples Test Engine qui correspondent à vos besoins de test. Voici des invites personnalisées pour les scénarios de test courants :

Exemples d’invites ButtonClicker

L’exemple ButtonClicker illustre les tests de base de la fonctionnalité du compteur. Utilisez ces invites :

Invite :
Générer un test pour mon application de compteur avec une structure similaire à l’exemple ButtonClicker. Mon application a des boutons nommés « IncrementBtn » et « ResetBtn » avec un « CounterLabel » qui affiche le nombre actuel. Créez un test qui vérifie que les deux boutons fonctionnent correctement et que le nombre maximal est de 10.

Invite :
Créer un test pour mon application d’interaction de bouton en utilisant l’exemple ButtonClicker comme référence. Mon application dispose d’un « SubmitButton » qui ne doit être activé que lorsque les champs « NameInput » et « EmailInput » sont renseignés. Générer un plan de test avec des étapes Power Fx pour valider ce comportement.

Invites de test de galerie

Les exemples BasicGallery et NestedGallery montrent comment tester les interactions de la galerie :

Invite :
Générer un test pour mon application de galerie où j’ai une galerie « Produits » avec des éléments de produit contenant les contrôles « TitleLabel », « PriceLabel » et « SelectButton ». Utilisez l’exemple de structure BasicGallery pour vérifier que je peux sélectionner des éléments et que les détails corrects apparaissent dans un « DetailPanel ».

Invites d’opérations sur les données

L’exemple Dataverse illustre les tests des opérations sur les données :

Invite :
Créer un test pour mon application CRM à l’aide de l’exemple de modèle Dataverse. Tester que je peux créer un enregistrement Contact, le mettre à jour, puis vérifier que les modifications persistent. Inclure à la fois les tests de l’interface utilisateur et les opérations directes Dataverse.

Invites de test d’IA

Pour tester les fonctionnalités basées sur l’IA, reportez-vous à l’exemple d’invite IA :

Invite :
Générer un test pour mon application d’analyse des sentiments basé sur l’exemple d’invite d’IA. Mon application dispose d’une zone de texte « FeedbackInput » et AI Builder permet de la classer comme positive, négative ou neutre. Créer un test qui valide différentes entrées produisent les sorties attendues dans des seuils acceptables.

Techniques avancées

Cette section fournit des exemples de fonctionnalités d’invite avancées.

Création de suites de tests multi-environnements

Vous pouvez inviter Copilot à générer des tests qui fonctionnent dans plusieurs environnements :

Invite :
Générer une suite de tests pour mon application pouvant s’exécuter dans les environnements DEV, TEST et PROD avec les variables de configuration appropriées pour chaque environnement.

Génération de scénarios de simulation de données

Pour les tests isolés avec la simulation de connecteur :

Invite :
Créer un test avec des simulations de réponses du connecteur pour mon application qui utilise le connecteur Office 365 Outlook. Le test doit simuler la réception d’e-mails et valider la logique de traitement de l’application.

Tester les capacités de l’IA et traiter les résultats non déterministes

Lorsque vous travaillez avec des applications alimentées par l’IA, les tests présentent des défis uniques, car les sorties de l’IA peuvent varier légèrement d’une exécution à l’autre, même avec des entrées identiques. Ce comportement non déterministe nécessite des approches de test spéciales.

Comprendre les tests non déterministes

Les tests non déterministes consistent à valider des résultats qui peuvent légitimement varier d’une exécution de test à l’autre :

• Sorties du modèle IA : réponses des modèles IA comme GPT ou des composants personnalisés AI Builder
• Scores de confiance : évaluations numériques qui peuvent fluctuer à l’intérieur de plages acceptables
• Contenu généré : texte ou recommandations produits par les systèmes d’IA

Utilisation de Preview.AIExecutePrompt pour tester de manière déterministe les capacités de l’IA

Le Test Engine fournit Preview.AIExecutePrompt qui permet la validation déterministe des réponses de l’IA. Cette approche vous permet d’effectuer ce qui suit :

• Exécuter des invites d’IA dans des scénarios de test
• Analyser et valider les réponses structurées
• Vérifier que les résultats critiques répondent aux attentes malgré les variations potentielles

Exemple : Note d’évaluation avec AI Builder

L’exemple suivant illustre l’utilisation de la fonction Preview.AIExecutePrompt pour tester un système d’évaluation alimenté par l’IA :

EvaluateTestQuestionPrompt(Prompt: TestQuestion): TestResult =
  With({
    Response: ParseJSON(
      Preview.AIExecutePrompt("PromptEvaluator",
      {
        Context: "You are a helpful agent asking about external customer service questions.",
        Question: Prompt.Question
      }).Text)
  },If(
    IsError(AssertNotError(Prompt.ExpectedRating=Response.Rating, Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating)),
    {PassFail: 1, Summary: Prompt.Question & ", Expected " & Prompt.ExpectedRating & ", Actual " & Response.Rating}, {PassFail: 0, Summary: "Pass " & Prompt.Question}
  ))

Dans cet exemple :

• Le test exécute une invite d’IA par rapport au modèle « PromptEvaluator »
• Il passe un contexte et une question pour évaluation
• Il valide que la note renvoyée correspond à la valeur attendue
• Il fournit un retour d’information clair sur la réussite ou l’échec du test

Vous pouvez explorer l’implémentation complète dans l’exemple d’invite d’IA dans le référentiel PowerApps-TestEngine.

Intégration de tests prenant en charge l’IA

Lorsque vous utilisez GitHub Copilot pour générer des tests pour des applications basées sur l’IA :

Invite :
Générer un test pour mon application basée sur l’IA qui utilise le traitement de formulaires AI Builder. Incluez des étapes de test qui valident les résultats de l’IA avec une tolérance appropriée pour les sorties non déterministes.

Dépannage et perfectionnement

Si GitHub Copilot génère des tests qui ne répondent pas à vos besoins :

• Affinez votre invite : soyez plus précis sur ce que vous souhaitez tester
• Fournissez des exemples : créez un lien vers des échantillons de test spécifiques qui correspondent au style souhaité
• Décomposez les tests complexes : demandez la génération de composants de test plus petits et ciblés
• Itérer : utilisez les réponses de Copilot pour affiner votre prochaine invite

Articles associés

Explorer les fonctionnalités de Test Engine
Parcourir le catalogue d’exemples Test Engine
En savoir plus sur les fonctions de test Power Fx
Comprendre le format de test YAML
Explorer les options d’authentification
Formation : Création d’applications avec le mode assistant GitHub Copilot