Partilhar via

Criar uma função C# Power Fx test (visualização)

Nota

As funcionalidades de pré-visualização não se destinam à produção e poderão ter caraterísticas restritas. Estas caraterísticas estão disponíveis antes do lançamento oficial, para que os clientes possam ter acesso antecipado e enviar comentários.

Microsoft Power Fx é uma poderosa linguagem low-code usada e Power Apps 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 "sem penhascos" do Power Apps Test Engine garante que os usuários possam estender as capacidades do Power Apps Test Engine sem bater em nenhuma 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 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 exemplos de como o Test Engine pode ser estendido.

Aqui está um exemplo de uma Power Fx função que fornece a estrutura de tópicos do código para manipular uma caixa de diálogo de consentimento condicional em um aplicativo 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.

Exemplo da caixa de diálogo de consentimento de conexão para um aplicativo que se conecta a um SharePoint site.

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.

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

Power Fx ajuda a abstrair a complexidade de aguardar condicionalmente a caixa de 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.

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 à caixa de diálogo confirmando 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 Table argumento permite que o processo de espera da caixa de diálogo de consentimento saia é um rótulo com o texto fornecido está 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

  • Namespace e Importações: Importa namespaces necessários e define o testengine.module namespace.
  • 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 manipula a caixa de diálogo de consentimento com um tempo limite.
  • Last updated on