Partager via

Créer une fonction de test C# Power Fx (version préliminaire)

Nonte

Les fonctionnalités en version préliminaire ne sont pas destinées à une utilisation en production et peuvent être restreintes. Ces fonctionnalités sont disponibles avant une version officielle afin que les clients puissent obtenir un accès anticipé et fournir des commentaires.

Microsoft Power Fx est un puissant langage low-code utilisé dans Power Apps, et il peut être étendu à l’aide de C# pour créer des fonctions de test personnalisées. Cet article explique comment créer une fonction de test C# Power Fx, offrant une expérience transparente aux créateurs et aux développeurs.

Le modèle avec une extensibilité sans failles de Power Apps Test Engine garantit que les utilisateurs peuvent étendre les capacités de Power Apps Test Engine sans se heurter à des barrières. Ce modèle permet aux développeurs de créer des fonctions personnalisées à l’aide de C#, qui peuvent être intégrées dans Power Fx pour gérer des scénarios complexes.

Modules de Test Engine

Les modules Test Engine pour Power Fx dans Test Engine sont construits à l’aide du modèle d’extensibilité. Vous pouvez utiliser le code produit comme exemples de la façon dont Test Engine peut être étendu.

Voici un exemple de fonction Power Fx qui fournit le plan de code pour gérer une boîte de dialogue de consentement conditionnel dans une application canevas.

Une boîte de dialogue de consentement est une invite qui s’affiche aux utilisateurs, leur demandant l’autorisation d’accéder à certaines ressources ou d’effectuer des actions spécifiques. Ce dialogue est crucial pour maintenir la sécurité et s’assurer que les utilisateurs sont au courant et acceptent les actions entreprises en leur nom.

Exemple de la boîte de dialogue d’autorisation de connexion pour une application se connectant à un site SharePoint.

La boîte de dialogue de consentement est importante, car elle permet d’empêcher les accès et les actions non autorisés. Il garantit que les utilisateurs sont informés et donnent leur consentement explicite avant que toute opération sensible ne soit effectuée. Ceci est important dans les scénarios où l’application a besoin d’accéder aux données utilisateur ou d’effectuer des actions et ce comportement conditionnel peut affecter les tests automatisés.

L’un des défis des dialogues de consentement est qu’ils peuvent rendre les tests non déterministes. L’invite peut s’afficher de manière conditionnelle en fonction de divers facteurs, tels que les autorisations de l’utilisateur ou les interactions précédentes. Cette apparence conditionnelle peut compliquer le processus de test, car Test Engine doit gérer ces boîtes de dialogue de manière appropriée.

Abstraction de la complexité avec Power Fx

Power Fx permet d’abstraire la complexité de l’attente conditionnelle de la boîte de dialogue de consentement et de la création de connexions si nécessaire. Les créateurs peuvent utiliser Power Fx pour définir la logique de gestion des dialogues de consentement de manière plus simple et intuitive.

Voici un exemple d’utilisation de Power Fx pour gérer une boîte de dialogue de consentement dans une page personnalisée :

Preview.ConsentDialog(Table({Text: "Center of Excellence Setup Wizard"}))

Dans cet exemple, la fonction ConsentDialog vérifie si la boîte de dialogue de consentement est visible. Si c’est le cas, la fonction peut répondre à la boîte de dialogue confirmant le consentement pour le compte de test. Une fois la boîte de dialogue gérée, les étapes de test restantes sont exécutées.

L’argument Table permet au processus d’attente de la boîte de dialogue de consentement de se terminer si une étiquette avec le texte fourni est visible.

Extension des fonctions de test Power Fx à l’aide de C#

L’exemple suivant est un exemple de code de base qui peut être utilisé comme point de départ pour compléter cet exemple :

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.
using Microsoft.Extensions.Logging;
using Microsoft.Playwright;
using Microsoft.PowerApps.TestEngine.Config;
using Microsoft.PowerApps.TestEngine.TestInfra;
using Microsoft.PowerFx;
using Microsoft.PowerFx.Core.Utils;
using Microsoft.PowerFx.Types;

namespace testengine.module
{
    /// <summary>
    /// This will check the custom pages of a model driven app looking for a consent dialog
    /// </summary>
    public class ConsentDialogFunction : ReflectionFunction
    {
        private readonly ITestInfraFunctions _testInfraFunctions;
        private readonly ITestState _testState;
        private readonly ILogger _logger;
        private static TableType SearchType = TableType.Empty()
              .Add(new NamedFormulaType("Text", FormulaType.String, displayName: "Text"));
    
        /// <summary>
        /// Constructor: Initializes the function with necessary dependencies, 
        /// including ITestInfraFunctions, ITestState, and ILogger.
        /// </summary>
        /// <param name="testInfraFunctions">The test infrastructure functions.</param>
        /// <param name="testState">The test state.</param>
        /// <param name="logger">The logger instance.</param>
        public ConsentDialogFunction(ITestInfraFunctions testInfraFunctions, 
           ITestState testState, 
           ILogger logger) : base(DPath.Root.Append(
               new DName("Preview")), 
               "ConsentDialog", 
               FormulaType.Blank, 
               SearchType)
               {
                  _testInfraFunctions = testInfraFunctions;
                  _testState = testState;
                  _logger = logger;
               }

        /// <summary>
        /// Execute Method: Logs the execution and calls the ExecuteAsync 
        /// method to handle the consent dialog.
        /// </summary>
        /// <param name="searchFor">The table value to search for.</param>
        /// <returns>A blank value.</returns>
        public BlankValue Execute(TableValue searchFor)
        {
            _logger.LogInformation("------------------------------\n\n" +
                "Executing ConsentDialog function.");

            ExecuteAsync(searchFor).Wait();

            return FormulaValue.NewBlank();
        }

        /// <summary>
        /// ExecuteAsync Method: Retrieves the page context and handles the consent dialog with a timeout.
        /// </summary>
        /// <param name="searchFor">The table value to search for.</param>
        /// <returns>A task representing the asynchronous operation.</returns>
        private async Task ExecuteAsync(TableValue searchFor)
        {
            var page = _testInfraFunctions
               .GetContext()
               .Pages
               .Where(p => p.Url.Contains("main.aspx"))
               .First();

            // ... IPage to handle consent dialog with timeout
        }
    }
}

Explication de l’exemple ConsentDialogFunction

  • Espace de noms et importations : importe les espaces de noms nécessaires et définit l’espace denoms testengine.module.
  • Définition de la classe : la classe ConsentDialogFunction hérite de ReflectionFunction et définit la fonction ConsentDialog personnalisée.
  • Constructeur : initialise la fonction avec les dépendances nécessaires, notamment ITestInfraFunctions, ITestState, et ILogger.
  • Méthode d’exécution : journalise l’exécution et appelle la méthode ExecuteAsync pour gérer la boîte de dialogue de consentement.
  • Méthode ExecuteAsync : récupère le contexte de la page et gère la boîte de dialogue de consentement avec un délai d’expiration.
  • Last updated on