Condividi tramite

Crea una funzione di test C# Power Fx (anteprima)

Nota

Le funzionalità di anteprima non sono destinate ad essere utilizzate per la produzione e sono soggette a restrizioni. Vengono rese disponibili prima di una versione ufficiale in modo che i clienti possano accedervi con anticipo e fornire i loro commenti.

Microsoft Power Fx è un potente linguaggio low-code utilizzato in Power Apps e può essere esteso utilizzando C# per creare funzioni di test personalizzate. Questo articolo spiega come creare una funzione di test in C# Power Fx , garantendo un'esperienza fluida sia per i creatori che per gli sviluppatori.

Il modello di estensibilità "senza difficoltà" di Test Engine garantisce che gli utenti possano estendere le funzionalità di Test Engine senza incontrare ostacoli. Power Apps Power Apps Questo modello consente agli sviluppatori di creare funzioni personalizzate utilizzando C#, che possono essere integrate per gestire scenari complessi. Power Fx

Moduli del motore di prova

I moduli del motore di test per Power Fx l'interno del motore di test sono creati utilizzando il modello di estensibilità. È possibile utilizzare il codice del prodotto come esempio di come Test Engine può essere esteso.

Ecco un esempio di una Power Fx funzione che fornisce lo schema del codice per gestire una finestra di dialogo di consenso condizionale in un' applicazione canvas.

Una finestra di dialogo di consenso è una finestra di dialogo che appare agli utenti e che chiede loro l'autorizzazione ad accedere a determinate risorse o a eseguire azioni specifiche. Questo dialogo è fondamentale per garantire la sicurezza e garantire che gli utenti siano consapevoli e accettino le azioni intraprese per loro conto.

Esempio di finestra di dialogo di consenso alla connessione per un'app che si connette a un sito. SharePoint

Il dialogo di consenso è importante perché aiuta a prevenire accessi e azioni non autorizzati. Garantisce che gli utenti siano informati e forniscano il loro consenso esplicito prima di eseguire qualsiasi operazione sensibile. Ciò è importante negli scenari in cui l'applicazione deve accedere ai dati dell'utente o eseguire azioni e questo comportamento condizionale potrebbe influire sui test automatizzati.

Una delle sfide dei dialoghi di consenso è che possono rendere i test non deterministici. Il messaggio può apparire in modo condizionale in base a vari fattori, come le autorizzazioni dell'utente o le interazioni precedenti. Questo aspetto condizionale può complicare il processo di test, poiché il Test Engine deve gestire queste finestre di dialogo in modo appropriato.

Astrarre la complessità con Power Fx

Power Fx aiuta ad astrarre la complessità dell'attesa condizionata del dialogo di consenso e della creazione di connessioni, se necessario. I maker possono utilizzare Power Fx per definire la logica per gestire i dialoghi sul consenso in modo più semplice e intuitivo.

Ecco un esempio di utilizzo di Power Fx per gestire una finestra di dialogo di consenso in una pagina personalizzata:

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

In questo esempio, la funzione ConsentDialog verifica se la finestra di dialogo del consenso è visibile. In tal caso, la funzione può rispondere alla finestra di dialogo di conferma del consenso per l'account di prova. Una volta gestito il dialogo, vengono eseguiti i restanti passaggi del test.

L'argomento Table consente di uscire dal processo di attesa del dialogo di consenso se è visibile un'etichetta con il testo fornito.

Estensione delle funzioni di test tramite C# Power Fx

L'esempio seguente è un codice di esempio che potrebbe essere utilizzato come punto di partenza per completare questo esempio:

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

Esempio di spiegazione di ConsentDialogFunction

  • Namespace e importazioni: importa i namespace necessari e definisce il namespace. testengine.module
  • Definizione della classe: La ConsentDialogFunction classe eredita da ReflectionFunction e definisce la funzione personalizzata ConsentDialog.
  • Costruttore: Inizializza la funzione con le dipendenze necessarie, tra cui ITestInfraFunctions, ITestState e ILogger.
  • Metodo di esecuzione: registra l'esecuzione e richiama il metodo ExecuteAsync per gestire la finestra di dialogo di consenso.
  • Metodo ExecuteAsync: recupera il contesto della pagina e gestisce la finestra di dialogo del consenso con un timeout.
  • Last updated on