Crear unha función de proba C# (vista previa) Power Fx

Nota

As funcionalidades de vista previa non se deseñaron para uso de produción e poden ter funcionalidade restrinxida. Estas funcionalidades están dispoñibles antes da versión oficial para que os clientes poidan obter acceso a elas rápido e fornecer comentarios.

Microsoft Power Fx é unha potente linguaxe de baixo código empregada en Power Apps e pódese ampliar usando C# para crear funcións de proba personalizadas. Este artigo explica como crear unha función de proba C# Power Fx , proporcionando unha experiencia sen fisuras tanto para creadores como para desenvolvedores.

O modelo de extensibilidade "sen precipicios" do motor de probas garante que os usuarios poidan ampliar as capacidades do motor de probas sen atoparse con ningunha barreira. Power Apps Power Apps Este modelo permite aos desenvolvedores crear funcións personalizadas usando C#, que se poden integrar en Power Fx para xestionar escenarios complexos.

Módulos do motor de probas

Os módulos do motor de probas para o motor de probas constrúense usando o modelo de extensibilidade. Power Fx Podes usar o código do produto como exemplos de como se pode ampliar Test Engine.

Exemplo de diálogo de consentimento

Aquí tes un exemplo dunha Power Fx función que proporciona o esquema do código para xestionar un diálogo de consentimento condicional nunha aplicación canvas.

Un diálogo de consentimento é unha solicitude que se lles aparece aos usuarios, solicitándolles permiso para acceder a certos recursos ou realizar accións específicas. Este diálogo é crucial para manter a seguridade e garantir que os usuarios coñezan e acepten as accións que se levan a cabo no seu nome.

O diálogo de consentimento é importante porque axuda a evitar o acceso e as accións non autorizadas. Garante que os usuarios estean informados e dean o seu consentimento explícito antes de realizar calquera operación sensible. Isto é importante en escenarios nos que a aplicación precisa acceder aos datos do usuario ou realizar accións e este comportamento condicional podería afectar ás probas automatizadas.

Desafíos cos diálogos de consentimento nas probas

Un dos desafíos dos diálogos de consentimento é que poden facer que as probas sexan non deterministas. A solicitude pode aparecer condicionalmente en función de varios factores, como os permisos do usuario ou as interaccións previas. Esta aparición condicional pode complicar o proceso de proba, xa que o motor de probas necesita xestionar estes diálogos axeitadamente.

Abstraendo a complexidade con Power Fx

Power Fx axuda a abstraer a complexidade de esperar condicionalmente o diálogo de consentimento e crear conexións se é necesario. Os creadores poden usar Power Fx para definir a lóxica para xestionar os diálogos de consentimento dun xeito máis sinxelo e intuitivo.

Exemplo: Xestionar o diálogo de consentimento con Power Fx

Aquí tes un exemplo de como usar Power Fx para xestionar un diálogo de consentimento nunha páxina personalizada:

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

Neste exemplo, a función ConsentDialog comproba se o diálogo de consentimento é visible. Se é así, a función pode responder ao diálogo confirmando o consentimento para a conta de proba. Unha vez xestionado o diálogo, execútanse os pasos de proba restantes.

O argumento Table permite que o proceso de espera do diálogo de consentimento saia se se ve unha etiqueta co texto proporcionado.

Ampliación de funcións de proba con C# Power Fx

O seguinte exemplo é un código de esquema de mostra que podería usarse como punto de partida para completar este exemplo:

// 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
        }
    }
}

Explicación do exemplo de ConsentDialogFunction

• Espazo de nomes e importacións: Importa os espazos de nomes necesarios e define o testengine.module espazo de nomes.
• Definición da clase: A clase ConsentDialogFunction herda de ReflectionFunction e define a función personalizada ConsentDialog.
• Construtor: Inicializa a función coas dependencias necesarias, incluíndo ITestInfraFunctions, ITestState e ILogger.
• Executar método: Rexistra a execución e chama o método ExecuteAsync para xestionar o diálogo de consentimento.
• Método ExecuteAsync: Recupera o contexto da páxina e xestiona o diálogo de consentimento cun tempo de espera.