Delen via

Een C# Power Fx testfunctie maken (preview)

Notitie

Preview-functies zijn niet bedoeld voor productiegebruik en bieden mogelijk beperkte functionaliteit. Deze functies zijn beschikbaar voorafgaand aan een officiële release, zodat klanten vroeg toegang kunnen krijgen en feedback kunnen geven.

Microsoft Power Fx is een krachtige low-code taal die wordt gebruikt in Power Apps en die kan worden uitgebreid met C# om aangepaste testfuncties te maken. In dit artikel wordt uitgelegd hoe u een C# Power Fx testfunctie maakt, waardoor zowel makers als ontwikkelaars een naadloze ervaring krijgen.

Het 'no cliffs'-uitbreidingsmodel van Test Engine zorgt ervoor dat gebruikers de mogelijkheden van de Power Apps Test Engine kunnen uitbreiden zonder dat ze tegen obstakels aanlopen. Power Apps Met dit model kunnen ontwikkelaars aangepaste functies maken met behulp van C#, die kunnen worden geïntegreerd in Power Fx om complexe scenario's te verwerken.

Test Engine-modules

De Test Engine-modules voor Power Fx binnen Test Engine worden gebouwd met behulp van het uitbreidbaarheidsmodel. U kunt de productcode gebruiken als voorbeeld voor hoe Test Engine kan worden uitgebreid.

Hier is een voorbeeld van een Power Fx functie die een overzicht biedt van de code voor het verwerken van een dialoogvenster voor voorwaardelijke toestemming in een canvastoepassing.

Een toestemmingsdialoogvenster is een venster dat aan gebruikers wordt getoond, waarin hun toestemming wordt gevraagd om toegang te krijgen tot bepaalde bronnen of specifieke acties uit te voeren. Deze dialoog is van cruciaal belang om de beveiliging te waarborgen en ervoor te zorgen dat gebruikers op de hoogte zijn van de acties die namens hen worden uitgevoerd, en hiermee akkoord gaan.

Voorbeeld van het dialoogvenster voor toestemming voor verbinding voor een app die verbinding maakt met een SharePoint site.

Het toestemmingsdialoogvenster is belangrijk omdat het ongeautoriseerde toegang en acties helpt voorkomen. Hiermee wordt ervoor gezorgd dat gebruikers worden geïnformeerd en expliciet toestemming geven voordat er gevoelige handelingen worden uitgevoerd. Dit is belangrijk in scenario's waarin de applicatie toegang moet hebben tot gebruikersgegevens of acties moet uitvoeren en dit voorwaardelijke gedrag van invloed kan zijn op geautomatiseerde tests.

Eén van de uitdagingen bij toestemmingsdialogen is dat ze tests niet-deterministisch kunnen maken. De prompt kan voorwaardelijk worden weergegeven op basis van verschillende factoren, zoals gebruikersmachtigingen of eerdere interacties. Deze voorwaardelijke weergave kan het testproces ingewikkelder maken, omdat de testengine deze dialoogvensters op de juiste manier moet verwerken.

Complexiteit abstraheren met Power Fx

Power Fx helpt de complexiteit van het voorwaardelijk wachten op de toestemmingsdialoog en het maken van verbindingen indien nodig te abstraheren. Makers kunnen hiermee Power Fx de logica voor het afhandelen van toestemmingsdialogen op een eenvoudigere en intuïtievere manier definiëren.

Hier is een voorbeeld van het gebruik van Power Fx om een toestemmingsdialoog op een aangepaste pagina te verwerken:

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

In dit voorbeeld controleert de ConsentDialog functie of het toestemmingsdialoogvenster zichtbaar is. Als dit het geval is, kan de functie op het dialoogvenster reageren en de toestemming voor het testaccount bevestigen. Zodra de dialoog is afgehandeld, worden de resterende teststappen uitgevoerd.

Het Table argument zorgt ervoor dat het wachtproces in de toestemmingsdialoog kan worden beëindigd als een label met de opgegeven tekst zichtbaar is.

Testfuncties uitbreiden met C# Power Fx

Het volgende voorbeeld is een voorbeeld van een codecontour die u als uitgangspunt kunt gebruiken om dit voorbeeld te voltooien:

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

Uitleg van het ConsentDialogFunction-voorbeeld

  • Naamruimte en import: Importeert de benodigde naamruimten en definieert de testengine.module naamruimte.
  • klassedefinitie: De ConsentDialogFunction klasse erft van ReflectionFunction en definieert de aangepaste functie ConsentDialog.
  • Constructor: initialiseert de functie met de benodigde afhankelijkheden, waaronder ITestInfraFunctions, ITestState en ILogger.
  • methode uitvoeren: registreert de uitvoering en roept de ExecuteAsync methode aan om het toestemmingsdialoogvenster af te handelen.
  • ExecuteAsync-methode: haalt de paginacontext op en verwerkt het toestemmingsdialoogvenster met een time-out.
  • Last updated on