Création de tests assistées par l’IA avec GitHub Copilot (déconseillé)

Note

Le moteur de test est déconseillé et sera supprimé dans une prochaine version. Utilisez des exemples Power Platform Playwright pour tester les fonctionnalités d’automatisation dans les services Power Platform et Dynamics 365.

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 comme 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 réutilisable.

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

Prérequis

Avant de commencer, assurez-vous d’avoir :

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
  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 solution dans Visual Studio Code

Utilisation de GitHub Copilot pour la création de tests

GitHub Copilot pouvez vous aider à générer différents 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 fournit une source riche de documents de référence pour GitHub Copilot. Vous pouvez aider Copilot générer des tests de qualité supérieure en :

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

Par exemple, vous pourriez :

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

Cette approche permet de Copilot comprendre les modèles de moteur de test Power Platform et de générer des tests plus précis.

Utilisation de GitHub Copilot en mode Agent

Le GitHub Copilot Chat de Visual Studio Code offre un mode Agent qui peut vous aider à générer des tests en fonction de vos fichiers de solution. Ce mode permet Copilot d’accéder et de comprendre plus en détail le contexte de votre projet.

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 Agent dans le sélecteur 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 requêtes comme celles-ci pour la génération de tests :

Objectif :
Générez une suite de tests complète pour une application canevas à l’aide du moteur de test Power Apps, modélisée après l’exemple ButtonClicker.

Invite :
Générez un test pour ./SolutionPackage/src/CanvasApps/src/MyApp/Src/App.fx.yaml en utilisant l’exemple sur https://github.com/microsoft/PowerApps-TestEngine/tree/main/samples/buttonclicker comme référence. Créez des cas attendus, des cas limites et des cas d’exception. Le test doit créer un fichier YAML de test et des étapes de test Power Fx, config.json et RunTest.ps1 en fonction de l’exemple pour me permettre d’exécuter le test.

Objectif :
Élaborez un plan de test détaillé pour une application pilotée par modèle afin de vous assurer que les fonctionnalités de base et la logique métier fonctionnent comme prévu.

Invite :
Créer un plan de test complet pour mon application pilotée par modèle située à ./SolutionPackage/src/Other/Solution.xml. Le test doit valider le chargement du formulaire, la création d’enregistrements et l’exécution des règles métier. Génère le YAML de test, les étapes Power Fx et un script PowerShell pour exécuter le test.

Objectif :
Élaborez un plan de test pour les entités Dataverse afin de vérifier les opérations CRUD via des actions Power Fx.

Invite :
Crée un plan de test complet pour mes entités Dataverse. Le test doit effectuer des actions Power Fx de création, de mise à jour et de suppression. Génère le YAML de test, les étapes Power Fx et un script PowerShell pour exécuter le test.

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 GitHub Copilot lors de la création de tests avec le moteur de test.

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 de Test Engine dans le contexte

Le catalogue de documentation samples.md répertorie tous les exemples disponibles à partir du référentiel du moteur de test, 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 Canvas à ./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. 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 de test et génère des tests plus précis et contextuels basés sur des exemples prouvés.

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

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

  • 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 des Applications Canvas

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

Invite :
Générez un test pour mon application Canvas à 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.

En savoir plus sur les tests d’applications canevas

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.

En savoir plus sur les tests des applications pilotées par modèle

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.

En savoir plus sur les tests Dataverse

Incitations de test spécifiques à l'échantillon

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 de requêtes 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.

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 ».

Requêtes d’opérations de 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 du Dataverse.

Requêtes de test d’IA

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

Invite :
Générez un test pour mon application d’analyse de sentiment en utilisant l’exemple de requête IA. Mon application a une zone de texte « FeedbackInput » et utilise AI Builder pour la classer comme positive, négative ou neutre. Créer un test qui valide que 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 moquerie de données

Pour les tests isolés avec le moquage de connecteur :

Invite :
Créez un test avec des réponses de connecteur fictifs 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 :

  • AI Model Outputs : Réponses à partir de modèles IA tels que GPT ou composants de AI Builder personnalisés
  • 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 : Évaluation des notes 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 requête IA par rapport au modèle « PromptEvaluator »
  • Il transmet un contexte et une question pour l'é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

Lors de l’utilisation de GitHub Copilot pour générer des tests pour les applications basées sur l’IA :

Invite :
Générez un test pour mon application basée sur l’IA qui utilise AI Builder traitement de formulaire. 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
  • Iterate : utilisez les réponses de Copilot pour affiner votre invite suivante

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
Training : Création d’applications en mode assistant Copilot GitHub

  • Last updated on