Vytvoření jednotkových testů ze spuštění standardního pracovního postupu v Azure Logic Apps ve Visual Studio Code

Platí pro: Azure Logic Apps (Standard)

Testování částí je základním postupem, který zajišťuje spolehlivost a přesnost vaší aplikace nebo řešení v průběhu životního cyklu vývoje softwaru. Testy jednotek pomáhají efektivně a systematicky ověřovat klíčové komponenty ve vašem řešení.

Pro pracovní postupy standardní aplikace logiky můžete vytvářet testy jednotek pomocí editoru Visual Studio Code a rozšíření Azure Logic Apps (Standard). Tato funkce umožňuje používat dříve spouštěné pracovní postupy k vytváření testů jednotek a jejich přizpůsobení scénářům podporovaným řešením aplikace logiky. Tento přístup nabízí následující výhody:

Znovupoužití běhů pracovního postupu pro generování fiktivních dat pro konkrétní operace v pracovním postupu.

Tato data umožňují testovat pracovní postupy bez nutnosti volat externí služby, systémy nebo rozhraní API. Ušetříte čas a pracovní postup zůstane v souladu se skutečným scénářem provádění pracovního postupu.
Zvýšení kvality pracovního postupu identifikací a řešením potenciálních problémů před nasazením do jiných prostředí.
Zjednodušte integraci jednotkových testů do procesu vývoje a zajistěte konzistentní a přesné chování pracovního postupu.

Tato příručka ukazuje, jak vytvořit definici jednotkového testu z běhu pracovního postupu. Tato definice napodobí externí volání z každé operace pracovního postupu beze změny logiky pracovního postupu. Když vytvoříte jednotkový test z proběhnutí pracovního postupu, získáte projekt jednotkového testu obsahující dvě složky:

Složka, která obsahuje silně typované třídy pro každou simulovanou operaci v pracovním postupu.
Složka pro každou definici testu jednotek, která obsahuje následující soubory:
- Soubor JSON, který představuje vygenerované napodobené operace ve vašem pracovním postupu.
- Soubor C#, který obsahuje příklad třídy a metod, které používáte k nastavení vlastních asercí, aby se ověřilo, že se pracovní postup chová podle očekávání a že je spolehlivý a předvídatelný ve vašem širším ekosystému Azure.

Požadavky

Účet a předplatné Azure. Pokud předplatné nemáte, zaregistrujte si bezplatný účet Azure.
Projekt logické aplikace typu Standard v editoru Visual Studio Code, který obsahuje alespoň jeden dříve a místně spuštěný pracovní postup pro vytvoření jednotkového testu.

Další informace o nastavení editoru Visual Studio Code a vytváření projektů najdete v tématu Vytváření pracovních postupů standardní aplikace logiky pomocí editoru Visual Studio Code.

Omezení a známé problémy

Tato verze v současné době podporuje pouze jazyk C# pro vytváření testů jednotek.
Tato verze nepodporuje neposměšné akce. Ujistěte se, že všechny akce v rámci provádění pracovního postupu jsou simulované.
Tato verze nepodporuje následující typy akcí:
- Akce integračního účtu
- Akce mapovače dat
- Vlastní akce kódu
- Akce XML
- Akce Liquid
- Akce kódování a dekódování EDI

Projděte si základní koncepty.

Následující seznam obsahuje základní, ale důležité koncepty testů jednotek pro standardní pracovní postupy:

Jednotkový test logické aplikace

Řízené spuštění pracovního postupu, které vloží napodobené objekty. Tyto objekty představují buď trigger pracovního postupu, nebo akce, které závisí na externích službách nebo systémech.
Akce pro testování

Akce pracovního postupu, která závisí na externí službě nebo systému. Tyto akce můžete převést na mockované akce pro vytvoření a spuštění jednotkového testu.

Vytvořte jednotkový test z běhu pracovního postupu

V editoru Visual Studio Code otevřete projekt aplikace logiky Standard.
Na panelu nástrojů Visual Studio Code v nabídce Spustit vyberte Spustit ladění. (Klávesnice: Stiskněte klávesu F5)
Vraťte se do okna Průzkumníka . V projektu rozbalte složku definice pracovního postupu.
Otevřete místní nabídku workflow.json a vyberte Přehled.
Na stránce přehledu v části Historie spuštění vyberte spuštění pracovního postupu, které chcete použít k vytvoření jednotkového testu.
Na panelu nástrojů historie spuštění vyberte Vytvořit jednotkový test ze spuštění.

Zadejte název, který se má použít pro test jednotek, třídu testování jednotek a soubor jazyka C#.

V okně Průzkumníka se ve složce projektu aplikace logiky zobrazí nová složka projektu s názvem Testy. Složka Testy obsahuje následující složky a soubory:

Složka nebo soubor	Popis
`Tests` \|\| <`logic-app-name`>	Ve složce `Tests` se zobrazí složka <`logic-app-name`>, když do projektu logické aplikace přidáte jednotkové testy.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`>	Ve složce <`logic-app-name`> se objeví složka <`workflow-name`>, když přidáte jednotkové testy pro pracovní postup.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| `MockOutputs` \|\|\|\|\|<`operation-name-outputs`>.`cs`	Ve složce <`workflow-name`> je složka `MockOutputs`, která obsahuje soubor C# (.cs) se silně typovanými třídami pro každou operaci konektoru v pracovním postupu. Každý název souboru .cs používá následující formát: < `operation-name` >[`Trigger\\|Action`]`Output.cs` Pokud operace konektoru obsahuje dynamické kontrakty, zobrazí se pro každý dynamický typ třída. Dynamický typ odkazuje na parametr operace, který má různé vstupy a výstupy na základě hodnoty zadané pro tento parametr. Tyto třídy můžete použít k rozšíření jednotkových testů a vytvoření nových mocků od začátku.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| <`unit-test-name`> \|\|\|\|\| <`unit-test-name`>`-mock.json` \|\|\|\|\| <`unit-test-name`>`.cs`	<`workflow-name`> Ve složce <`unit-test-name`> složka obsahuje následující soubory: – Soubor <`unit-test-name`>`-mock.json` obsahuje reprezentaci JSON pro vygenerované mocky na základě spuštění pracovního procesu, které vytvořily jednotkový test. – Soubor <`unit-test-name`>`.cs` obsahuje ukázkovou třídu C# a metody, které využívají soubor *`-mock.json`** ke spuštění a ověření výsledků. Tento soubor můžete upravit tak, aby odpovídal konkrétním testovacím scénářům.

Kontrola souboru *-mock.json

Tento soubor obsahuje následující hlavní části:

`triggerMocks` oddíl

Část triggerMocks obsahuje simulovaný výsledek ze spouštěče pracovního postupu. Tato část se vyžaduje ke spuštění provádění pracovního postupu, jak je znázorněno v následujícím příkladu:

{
    "triggerMocks": {
        "When_messages_are_available_in_a_queue_(peek-lock)": {
            "name": "When_messages_are_available_in_a_queue_(peek-lock)",
            "status": "Succeeded",
            "outputs": {
                "body": {
                    "contentData": {
                        "messageId": "1234",
                        "status": "new",
                        "contentType": "application/json",
                        "userProperties": {},
                        "scheduledEnqueueTimeUtc": "1/1/0001 12:00:00 AM",
                        "timeToLive": "14.00:00:00",
                        "deliveryCount": 1,
                        "enqueuedSequenceNumber": 0,
                        "enqueuedTimeUtc": "2025-04-07T01:10:09.738Z",
                        "lockedUntilUtc": "2025-04-07T01:11:09.769Z",
                        "lockToken": "78232fa8-03cf-4baf-b1db-3375a64e0ced",
                        "sequenceNumber": 5
                    }
                }
            }
        }
    },
    "actionMocks": {...}
}

`actionMocks` oddíl

Pro každou napodobenou akci ve spuštění actionMocks pracovního postupu obsahuje oddíl napodobenou akci a zaručuje řízené spuštění pracovního postupu.

{
    "triggerMocks": {...},
    "actionMocks": {
        "Call_External_API": {
            "name": "Call_External_API",
            "status": "Succeeded",
            "outputs": {
                "statusCode": 200,
                "body": {
                    "status": "Awesome!"
                }
            }
        },
        "CompleteMessage": {
            "name": "CompleteMessage",
            "status": "Succeeded",
            "outputs": {
                "statusCode": "OK",
                "body": {}
            }
        }
    }
}

Zkontrolujte soubor jednotkového testu *.cs

Tato třída pro jednotkové testování poskytuje architekturu pro testování standardních pracovních postupů v aplikaci Logic simulací triggerů a akcí. Tato třída umožňuje testovat pracovní postupy bez skutečného volání externích služeb nebo rozhraní API.

Struktura testovací třídy

Typická třída jednotkového testu používá následující strukturu.

[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.
}

Metoda Setup()

Tato metoda vytvoří instanci třídy TestExecutor pomocí cesty ke konfiguračnímu souboru nastavení testu. Metoda se spustí před každým spuštěním testu a vytvoří novou instanci TestExecutor.

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

Ukázkové testovací metody

Následující část popisuje ukázkové testovací metody, které můžete použít ve třídě jednotkových testů.

Test statických napodobených dat

Následující metoda ukazuje, jak pomocí statických napodobených dat otestovat pracovní postup. V této metodě můžete provést následující úlohy:

Nastavte hodnoty vlastností na mockovaných akcích.
Spusťte pracovní postup s nakonfigurovanými napodobenými daty.
Potvrďte, že spuštění proběhlo úspěšně.

[TestMethod]
public async Task <workflow-name>_<unit-test-name>_ExecuteWorkflow_SUCCESS_Sample1()
{
    // PREPARE mock: Generate mock action and trigger data.
    var mockData = this.GetTestMockDefinition();
    var sampleActionMock = mockData.ActionMocks["Call_External_API"];
    sampleActionMock.Outputs["your-property-name"] = "your-property-value";

    // ACT: Create the UnitTestExecutor instance. Run the workflow with mock data.
    var testRun = await this.TestExecutor
        .Create()
        .RunWorkflowAsync(testMock: mockData).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);
}

Dynamický test simulovaných dat

Následující metoda ukazuje, jak používat dynamická napodobená data s metodami zpětného volání. Tento přístup nabízí dvě možnosti, které dynamicky generují napodobená data:

Definujte samostatnou metodu zpětného volání.
Použijte vloženou funkci lambda.

Oba přístupy umožňují vytvářet dynamické odpovědi na základě kontextu provádění testů jednotek.

[TestMethod]
public async Task <workflow-name>_<unit-test-name>_ExecuteWorkflow_SUCCESS_Sample2()
{
    // PREPARE: Generate mock action and trigger data.
    var mockData = this.GetTestMockDefinition();
    
    // OPTION 1: Define a callback class.
    mockData.ActionMocks["Call_External_API"] = new CallExternalAPIActionMock(
        name: "Call_External_API", 
        onGetActionMock: CallExternalAPIActionMockOutputCallback);

    // OPTION 2: Define an inline lambda function.
    mockData.ActionMocks["Call_External_API"] = 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 UnitTestExecutor instance. Run the workflow with mock data.
    var testRun = await this.TestExecutor
        .Create()
        .RunWorkflowAsync(testMock: mockData).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);
}

Test scénáře chyb

Následující metoda ukazuje, jak otestovat podmínky selhání. V této metodě můžete provést následující úlohy:

Nakonfigurujte napodobené akce tak, aby selhaly s konkrétními kódy chyb a zprávami.
Ověřte, že pracovní postup zpracovává tyto chybové stavy správně.

[TestMethod]
public async Task <workflow-name>_<unit-test-name>_ExecuteWorkflow_FAILED_Sample3()
{
    // PREPARE: Generate mock action and trigger data.
    var mockData = this.GetTestMockDefinition();
    var mockError = new TestErrorInfo(code: ErrorResponseCode.BadRequest, message: "Input is invalid.");
    mockData.ActionMocks["Call_External_API"] = new CallExternalAPIActionMock(
        status: TestWorkflowStatus.Failed, 
        error: mockError);

    // ACT: Create UnitTestExecutor instance. Run the workflow with mock data.
    var testRun = await this.TestExecutor
        .Create()
        .RunWorkflowAsync(testMock: mockData).ConfigureAwait(continueOnCapturedContext: false);

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

Pomocné metody

Následující část popisuje metody používané vzorovými testovacími metodami. Pomocné metody se zobrazí pod testovacími metodami v definici třídy.

GetTestMockDefinition()

Následující metoda načte definici napodobení ze souboru JSON. Tuto metodu můžete upravit, pokud jsou napodobená data uložená v jiném umístění nebo formátu.

private TestMockDefinition GetTestMockDefinition()
{
    var mockDataPath = Path.Combine(TestExecutor.rootDirectory, "Tests", TestExecutor.logicAppName, 
        TestExecutor.workflow, "<unit-test-name>", "<unit-test-name>-mock.json");
    return JsonConvert.DeserializeObject<TestMockDefinition>(File.ReadAllText(mockDataPath));
}

Metoda zpětného volání

Následující metoda dynamicky generuje napodobená data. Název metody se liší podle názvu napodobené akce v testovacích metodách pro statická nebo dynamická napodobená data. Tuto metodu můžete upravit tak, aby vracela různé napodobení odpovědí na základě požadavků na váš testovací scénář, nebo ji můžete použít jako šablonu k vytvoření vlastních metod zpětného volání.

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()

        }
    );
}

Vytváření testů jednotek z definic standardních pracovních postupů v Azure Logic Apps pomocí editoru Visual Studio Code

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-06-09