Crie uma função de teste C# Power Fx (visualização)

Microsoft Power Fx é uma poderosa linguagem de baixo código usada em Power Apps e pode ser estendida usando C# para criar funções de teste personalizadas. Este artigo explica como criar uma função de teste em C# Power Fx , proporcionando uma experiência perfeita para criadores e desenvolvedores.

O modelo de extensibilidade "sem penhascos" do Test Engine garante que os usuários possam estender os recursos do Test Engine sem encontrar nenhuma barreira. Power Apps Power Apps Este modelo permite que os desenvolvedores criem funções personalizadas usando C#, que podem ser integradas para lidar com cenários complexos. Power Fx

Módulos do mecanismo de teste

Os módulos do mecanismo de teste para Power Fx dentro do mecanismo de teste são construídos usando o modelo de extensibilidade. Você pode usar o código do produto como exemplo de como o Test Engine pode ser estendido.

Exemplo de diálogo de consentimento

Aqui está um exemplo de uma Power Fx função que fornece o esboço do código para manipular um diálogo de consentimento condicional em um aplicativo Canvas.

Uma caixa de diálogo de consentimento é um prompt que aparece aos usuários, solicitando sua permissão para acessar determinados recursos ou executar ações específicas. Este diálogo é crucial para manter a segurança e garantir que os usuários estejam cientes e concordem com as ações tomadas em seu nome.

O diálogo de consentimento é importante porque ajuda a evitar acesso e ações não autorizados. Ele garante que os usuários sejam informados e forneçam seu consentimento explícito antes que qualquer operação sensível seja realizada. Isso é importante em cenários em que o aplicativo precisa acessar dados do usuário ou executar ações, e esse comportamento condicional pode afetar testes automatizados.

Desafios com diálogos de consentimento em testes

Um dos desafios dos diálogos de consentimento é que eles podem tornar os testes não determinísticos. O prompt pode aparecer condicionalmente com base em vários fatores, como permissões do usuário ou interações anteriores. Essa aparência condicional pode complicar o processo de teste, pois o mecanismo de teste precisa lidar com esses diálogos adequadamente.

Abstraindo a complexidade com Power Fx

Power Fx ajuda a abstrair a complexidade da espera condicional pelo diálogo de consentimento e criar conexões, se necessário. Os criadores podem usar Power Fx para definir a lógica para lidar com diálogos de consentimento de uma maneira mais direta e intuitiva.

Exemplo: Lidando com o diálogo de consentimento com Power Fx

Aqui está um exemplo de uso de Power Fx para manipular um diálogo de consentimento em uma página personalizada:

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

Neste exemplo, a função verifica se o diálogo de consentimento está visível. ConsentDialog Se for, a função pode responder ao diálogo confirmando o consentimento para a conta de teste. Depois que o diálogo é manipulado, as etapas restantes do teste são executadas.

O argumento permite que o processo de espera do diálogo de consentimento saia quando um rótulo com o texto fornecido estiver visível. Table

Estendendo funções de teste usando C# Power Fx

O exemplo a seguir é um exemplo de código de estrutura que pode ser usado como ponto de partida para concluir 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
        }
    }
}

Explicação do exemplo ConsentDialogFunction

• Namespace e importações: importa os namespaces necessários e define o testengine.module namespace.
• Definição de classe: A ConsentDialogFunction classe herda de ReflectionFunction e define a função personalizada ConsentDialog.
• Construtor: Inicializa a função com dependências necessárias, incluindo ITestInfraFunctions, ITestState e ILogger.
• Método de execução: Registra a execução e chama o ExecuteAsync método para manipular o diálogo de consentimento.
• Método ExecuteAsync: recupera o contexto da página e manipula o diálogo de consentimento com um tempo limite.