Criar uma função de teste Power Fx em C# (obsoleta)

Microsoft Power Fx é uma poderosa linguagem low-code 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 C# Power Fx , fornecendo uma experiência perfeita para criadores e desenvolvedores.

O modelo de extensibilidade do Power Apps Test Engine, conhecido como 'sem limites', garante que os utilizadores podem expandir as capacidades do Power Apps Test Engine sem encontrar qualquer barreira. Esse modelo permite que os desenvolvedores criem Power Fx funções personalizadas usando C#, que podem ser integradas para lidar com cenários complexos.

Módulos do motor de teste

Os módulos do Test Engine para Power Fx dentro do Test Engine foram criados utilizando o modelo de extensibilidade. Você pode usar o código do produto como exemplos de como o Test Engine pode ser estendido.

Exemplo de caixa de diálogo de consentimento

Aqui está um exemplo de uma função Power Fx que fornece a estrutura do código para gerir uma caixa de diálogo de consentimento condicional numa aplicação de tela.

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

A caixa de diálogo de consentimento é importante porque ajuda a impedir o acesso e as ações não autorizadas. Assegura que os utilizadores são informados e dão o seu consentimento explícito antes da realização de quaisquer operações sensíveis. Isso é importante em cenários em que o aplicativo precisa acessar dados do utilizador 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 de utilizador ou interações anteriores. Essa aparência condicional pode complicar o processo de teste, pois o mecanismo de teste precisa lidar com essas caixas de diálogo adequadamente.

Abstrair a complexidade com Power Fx

O Power Fx ajuda a abstrair a complexidade de esperar condicionalmente pelo diálogo de consentimento e criar ligaçõ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: Processamento do diálogo de consentimento com o Power Fx

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

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

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

O argumento Table permite que o processo de espera da caixa de diálogo de consentimento termine se um rótulo com o texto fornecido estiver visível.

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

O exemplo a seguir é um código de estrutura de tópicos de exemplo 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 de ConsentDialogFunction

• Espaço de nomes e Importações: Importa os espaços de nomes necessários e define o espaço de nomes testengine.module.
• Definição de classe: A ConsentDialogFunction classe herda de ReflectionFunction e define a função ConsentDialog personalizada.
• Construtor: Inicializa a função com as 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 a caixa de diálogo de consentimento.
• Método ExecuteAsync: recupera o contexto da página e lida com a janela de diálogo de consentimento com um tempo limite.