Eenheidstests maken van Standard-werkstroomdefinities in Azure Logic Apps met Visual Studio Code

Van toepassing op: Azure Logic Apps (Standard)

Eenheidstests zijn een essentiële praktijk die uw app of oplossing betrouwbaar en nauwkeurig houdt gedurende de levenscyclus van softwareontwikkeling. Met eenheidstests kunt u de belangrijkste onderdelen in uw oplossing efficiënt en systematisch valideren.

Voor werkstromen voor logische apps van Standard kunt u eenheidstests maken met behulp van Visual Studio Code en de Azure Logic Apps-extensie (Standard). Met deze mogelijkheid kunt u werkstroomdefinities gebruiken om eenheidstests te maken en deze aan te passen aan scenario's die worden ondersteund door uw logische app-oplossing, allemaal zonder dat u verbindingen nodig hebt met externe services, systemen of API's. Met deze methode kunt u uw werkstromen testen zonder te hoeven communiceren met externe services, systemen of API's en biedt de volgende voordelen:

• Verbeter de kwaliteit van de werkstroom door potentiële problemen te identificeren en op te lossen voordat u implementeert in andere omgevingen.

• Stroomlijn de integratie van eenheidstests met uw ontwikkelproces en zorg voor consistent en nauwkeurig werkstroomgedrag.

Deze handleiding laat zien hoe u een eenheidstestdefinitie maakt op basis van een werkstroom. Met deze definitie worden de externe aanroepen van elke werkstroombewerking gesimuleerd zonder de werkstroomlogica te wijzigen. Wanneer u een eenheidstest voor een werkstroom maakt, krijgt u een eenheidstestproject met de volgende mappen:

• Een map met sterk getypte klassen voor elke gesimuleerde bewerking in uw werkstroom.

• Een map voor elke eenheidstestdefinitie. Deze map bevat een C#-bestand dat een voorbeeldklasse en methoden bevat. U gebruikt deze klasse en methoden om uw eigen asserties in te stellen, te bevestigen dat de werkstroom werkt zoals verwacht en ervoor te zorgen dat de werkstroom betrouwbaar en voorspelbaar werkt in uw grotere Azure-ecosysteem.

Vereiste voorwaarden

• Een Azure-account en -abonnement. Als u nog geen abonnement hebt, meld u dan aan voor een gratis Azure-account.

• Een standaard logische app-project in Visual Studio Code met ten minste één werkstroomdefinitie die moet worden gebruikt voor het maken van een eenheidstest.

  Zie Werkstromen voor logische apps maken met Visual Studio Code voor meer informatie over het instellen en maken van projecten in Visual Studio Code.

Beperkingen en bekende problemen

• Deze release ondersteunt momenteel alleen C# voor het maken van eenheidstests.

• Deze release biedt geen ondersteuning voor niet-gesimuleerde acties. Zorg ervoor dat alle acties in het uitvoeringspad van de werkstroom worden gesimuleerd.

• Deze release biedt geen ondersteuning voor de volgende actietypen:

  • Acties voor integratieaccounts
  • EDI-acties coderen en decoderen

De basisconcepten bekijken

De volgende lijst bevat eenvoudige maar belangrijke concepten over eenheidstests voor Standaardwerkstromen:

• Unittest voor logische app

  Een gecontroleerde werkstroomuitvoering die mock-objecten injecteert. Deze objecten vertegenwoordigen de werkstroomtrigger of acties die afhankelijk zijn van externe services of systemen.

• Simuleerbare actie

  Een werkstroomactie die afhankelijk is van een externe service of systeem. U kunt deze acties converteren naar gesimuleerde acties voor het maken en uitvoeren van eenheidstests.

Een eenheidstest maken op basis van een werkstroomdefinitie

1. Open uw Standaard logica-app-project in Visual Studio Code.

2. Vouw in uw project de map met werkstroomdefinities uit.

3. Selecteer Open Designer in het snelmenu voor het workflow.json-bestand.

4. Op de werkbalk van de ontwerpfunctie selecteer Unittest maken.

   

5. Geef een naam op die moet worden gebruikt voor het eenheidstest-, eenheidstestklasse- en C#-bestand.

   Er wordt nu een nieuwe map met de naam Tests weergegeven in uw projectwerkruimte. Deze map heeft de volgende structuur:

   

   Map of bestand	Beschrijving
   Tests || <logic-app-name>	In de Tests map wordt een <logic-app-name> map weergegeven wanneer u eenheidstests toevoegt aan een logic app-project.
   Tests || <logic-app-name> ||| <workflow-name>	In de <logic-app-name> map wordt een <workflow-name> map weergegeven wanneer u eenheidstests voor een werkstroom toevoegt.
   Tests || <logic-app-name> ||| <workflow-name> |||| MockOutputs < operation-name-outputs >||||| .cs	In de <workflow-name> map bevat de MockOutputs map een C#-bestand (.cs) met sterk getypte klassen voor elke connectorbewerking in de werkstroom. Elke .cs bestandsnaam gebruikt de volgende indeling: < operation-name >[Trigger\|Action]Output.cs Als een connectorbewerking dynamische contracten heeft, wordt er een klasse weergegeven voor elk dynamisch type. Een dynamisch type verwijst naar een bewerkingsparameter met verschillende invoer- en uitvoerwaarden op basis van de waarde die voor die parameter is opgegeven. U kunt deze klassen gebruiken om uw eenheidstests uit te breiden en nieuwe mocks helemaal zelf te maken.
   Tests || <logic-app-name> ||| <workflow-name> |||| <unit-test-name> ||||| <unit-test-name>.cs	In de <workflow-name> map bevat de <unit-test-name> map een <unit-test-name>.cs bestand. U gebruikt dit bestand, dat een C#-voorbeeldklasse en -methoden bevat, om resultaten uit te voeren en te bevestigen. U kunt dit bestand bewerken zodat dit overeenkomt met uw specifieke testscenario's.

Bekijk het eenheidstestbestand *.cs

Deze unittestklasse biedt een framework voor het testen van standaardwerkstromen in Logic Apps door het mocken van triggers en acties. Met deze klasse kunt u werkstromen testen zonder externe services of API's aan te roepen.

Klassestructuur testen

Een typische eenheidstestklasse maakt gebruik van de volgende structuur:

[TestClass]
public class <unit-test-name>
{
    public TestExecutor TestExecutor;

    [TestInitialize]
    public void Setup()
    {
        this.TestExecutor = new TestExecutor("<workflow-name>/testSettings.config");
    }

    // Add test methods here.

    // Add helper methods here.
}

Methode Setup()

Met deze methode wordt de TestExecutor klasse geïnstitueerd met behulp van het pad naar het configuratiebestand voor testinstellingen. De methode wordt uitgevoerd vóór elke testuitvoering en maakt een nieuw exemplaar van TestExecutor.

[TestInitialize]
public void Setup()
{
    this.TestExecutor = new TestExecutor("<workflow-name>/testSettings.config");
}

Voorbeeldtestmethoden

In de volgende sectie worden voorbeeldtestmethoden beschreven die u in uw eenheidstestklasse kunt gebruiken.

Test van statische mockgegevens

De volgende methode laat zien hoe u statische mockgegevens gebruikt om uw werkstroom te testen. In deze methode kunt u de volgende taken uitvoeren:

• Stel eigenschapswaarden in voor uw gesimuleerde acties.
• Voer de werkstroom uit met de geconfigureerde simulatiegegevens.
• Controleer of de uitvoering is geslaagd.

[TestMethod]
public async Task <workflow-name>_<unit-test-name>_ExecuteWorkflow_SUCCESS_Sample1()
{
    // PREPARE mock: Generate mock trigger data.
    var triggerMockOutput = new WhenMessagesAreAvailableInAQueuePeeklockTriggerOutput();
    // Sample that shows how to set the properties for triggerMockOutput
    // triggerMockOutput.Body.Id = "SampleId";
    var triggerMock = new WhenMessagesAreAvailableInAQueuePeeklockTriggerMock(outputs: triggerMockOutput);

    // Generate mock action data.
    var actionMockOutput = new CallExternalAPIActionOutput();
    // Sample that shows how to set the properties for actionMockOutput
    // actionMockOutput.Body.Name = "SampleResource";
    // actionMockOutput.Body.Id = "SampleId";
    var actionMock = new CallExternalAPIActionMock(name: "Call_External_API", outputs: actionMockOutput);

    // ACT: Create the UnitTestExecutor instance. Run the workflow with mock data.
    var testMock = new TestMockDefinition(
        triggerMock: triggerMock,
        actionMocks: new Dictionary<string, ActionMock>()
        {
            {actionMock.Name, actionMock}
        });
    var testRun = await this.TestExecutor
        .Create()
        .RunWorkflowAsync(testMock: testMock).ConfigureAwait(continueOnCapturedContext: false);

    // ASSERT: Confirm successful workflow execution and that the status is 'Succeeded'.
    Assert.IsNotNull(value: testRun);
    Assert.AreEqual(expected: TestWorkflowStatus.Succeeded, actual: te
    stRun.Status);
}

Dynamische test van gesimuleerde gegevens

De volgende methode laat zien hoe u dynamische mockgegevens gebruikt met callback-methoden. Deze benadering biedt twee opties waarmee gesimuleerde gegevens dynamisch worden gegenereerd:

• Definieer een afzonderlijke callback-methode.
• Gebruik een inline lambda-functie.

Met beide benaderingen kunt u dynamische antwoorden maken op basis van de uitvoeringscontext van de eenheidstest.

[TestMethod]
public async Task <workflow-name>_<unit-test-name>_ExecuteWorkflow_SUCCESS_Sample2()
{
    // PREPARE: Generate mock trigger data.
    var triggerMockOutput = new WhenMessagesAreAvailableInAQueuePeeklockTriggerOutput();
    // Sample that shows how to set triggerMockOutput properties.
    // triggerMockOutput.Body.Flag = true;
    var triggerMock = new WhenMessagesAreAvailableInAQueuePeeklockTriggerMock(outputs: triggerMockOutput);

    // PREPARE: Generate mock action data.
    // OPTION 1: Define a callback class.
    var actionMock = new CallExternalAPIActionMock(name: "Call_External_API", onGetActionMock: CallExternalAPIActionMockOutputCallback);

    // OPTION 2: Define inline with a lambda function.
    /*var actionMock = new CallExternalAPIActionMock(name: "Call_External_API", onGetActionMock: (testExecutionContext) =>
    {
        return new CallExternalAPIActionMock(
            status: TestWorkflowStatus.Succeeded,
            outputs: new CallExternalAPIActionOutput {

                // If this account contains a JObject Body,
                // set the properties you want here:
                // Body = "something".ToJObject()

            }
        );
    });*/

    // ACT: Create the UnitTestExecutor instance. Run the workflow with mock data.
    var testMock = new TestMockDefinition(
        triggerMock: triggerMock,
        actionMocks: new Dictionary<string, ActionMock>()
        {
            {actionMock.Name, actionMock}
        });
    var testRun = await this.TestExecutor
        .Create()
        .RunWorkflowAsync(testMock: testMock).ConfigureAwait(continueOnCapturedContext: false);

    // ASSERT: Confirm successful workflow execution and that the status is 'Succeeded'.
    Assert.IsNotNull(value: testRun);
    Assert.AreEqual(expected: TestWorkflowStatus.Succeeded, actual: testRun.Status);
}

Helpermethoden

In de volgende sectie worden methoden beschreven die worden gebruikt door de voorbeeldtestmethoden. Helpermethoden worden weergegeven onder de testmethoden in de klassedefinitie.

Callbackmethode

Met de volgende methode worden gesimuleerde gegevens dynamisch gegenereerd. De naam van de methode varieert op basis van de gesimuleerde actienaam in de testmethoden voor statische of dynamische mockgegevens. U kunt deze methode bewerken om verschillende gesimuleerde antwoorden te retourneren op basis van uw vereisten voor het testscenario of deze als sjabloon gebruiken om uw eigen dynamische callback-methoden te maken.

public CallExternalAPIActionMock CallExternalAPIActionMockOutputCallback(TestExecutionContext context)
{
    // Sample mock data: Dynamically change the mocked data for 'actionName'.
    return new CallExternalAPIActionMock(
        status: TestWorkflowStatus.Succeeded,
        outputs: new CallExternalAPIActionOutput {

            // If this account contains a JObject Body, 
            // set the properties you want here:
            // Body = "something".ToJObject()

        }
    );
}

Verwante inhoud

• Eenheidstests maken van Standard-werkstroomuitvoeringen in Azure Logic Apps met Visual Studio Code