Egységtesztek létrehozása standard munkafolyamat-futtatásokból az Azure Logic Appsben a Visual Studio Code használatával

A következőkre vonatkozik: Azure Logic Apps (Standard)

Az egységtesztelés alapvető gyakorlat, amely megbízható és pontos marad az alkalmazás vagy a megoldás számára a szoftverfejlesztési életciklus során. Az egységtesztek segítségével hatékonyan és szisztematikusan ellenőrizheti a megoldás kulcsösszetevőit.

Standard logikaialkalmazás-munkafolyamatok esetén egységteszteket hozhat létre a Visual Studio Code és az Azure Logic Apps (Standard) bővítmény használatával. Ez a funkció lehetővé teszi, hogy a korábban végrehajtott munkafolyamat-futtatásokkal egységteszteket hozzon létre, és a logikai alkalmazás megoldás által támogatott forgatókönyvekhez szabja őket. Ez a megközelítés a következő előnyöket nyújtja:

A munkafolyamat-futtatások újbóli használata a munkafolyamat adott műveleteihez tartozó mintaadatok létrehozásához.

Ezek az adatok lehetővé teszi a munkafolyamatok tesztelését anélkül, hogy külső szolgáltatásokat, rendszereket vagy API-kat kellene meghívnia. Időt takaríthat meg, és a munkafolyamat a tényleges munkafolyamat-végrehajtási forgatókönyvnek megfelelően marad.
A munkafolyamat minőségének javítása a lehetséges problémák azonosításával és megoldásával, mielőtt üzembe helyeznénk más környezetekben.
Egyszerűsítheti az egységtesztek integrációját a fejlesztési folyamattal, miközben egységes és pontos munkafolyamat-viselkedést biztosít.

Ez az útmutató bemutatja, hogyan hozhat létre egységtesztdefiníciót munkafolyamat-futtatásból. Ez a definíció az egyes munkafolyamat-műveletek külső hívásait szimulálja a munkafolyamat-logika módosítása nélkül. Amikor egy munkafolyamat-futtatásból hoz létre egységtesztet, egy egységtesztelési projektet kap, amely két mappát tartalmaz:

Olyan mappa, amely a munkafolyamat minden egyes szimulálható műveletéhez erősen gépelt osztályokat tartalmaz.
Az egyes egységteszt-definíciók mappája, amely a következő fájlokat tartalmazza:
- Egy JSON-fájl, amely a munkafolyamatban létrehozott szimulált műveleteket jelöli.
- Egy C#-fájl, amely egy mintaosztályt és a saját állítások beállításához használt metódusokat tartalmaz, megerősíti, hogy a munkafolyamat a várt módon működik, és győződjön meg arról, hogy a munkafolyamat megbízhatóan és kiszámíthatóan viselkedik a nagyobb Azure-ökoszisztémában.

Előfeltételek

Azure-fiók és -előfizetés. Ha még nincs előfizetése, regisztráljon egy ingyenes Azure-fiókra.
Standard logikai alkalmazásprojekt a Visual Studio Code-ban, amely legalább egy korábban és helyileg végrehajtott munkafolyamatot tartalmaz egy egységteszt létrehozásához.

A Visual Studio Code beállításával és a projekt létrehozásával kapcsolatos további információkért tekintse meg a Standard logikai alkalmazás munkafolyamatainak létrehozása a Visual Studio Code-tal című témakört.

Korlátozások és ismert problémák

Ez a kiadás jelenleg csak c#-t támogat egységtesztek létrehozásához.
Ez a kiadás nem támogatja a nem szimulált műveleteket. Győződjön meg arról, hogy a munkafolyamat végrehajtási útvonalának összes művelete szimulálva van.
Ez a kiadás nem támogatja a következő művelettípusokat:
- Integrációs fiókműveletek
- Adattérképező műveletei
- Egyéni kódműveletek
- XML-műveletek
- Likvid műveletek
- Az EDI kódolja és dekódolja a műveleteket

Az alapfogalmak áttekintése

Az alábbi lista alapszintű, de fontos fogalmakat tartalmaz a standard munkafolyamatok egységtesztjeivel kapcsolatban:

Logikai alkalmazásegység tesztelése

Felügyelt munkafolyamat-végrehajtás, amely szimulált objektumokat injektál. Ezek az objektumok a munkafolyamat-eseményindítót vagy a külső szolgáltatásoktól vagy rendszerektől függő műveleteket jelölik.
Modellezhető művelet

Külső szolgáltatástól vagy rendszertől függő munkafolyamat-művelet. Ezeket a műveleteket modellezett műveletekké alakíthatja az egységtesztek létrehozásához és végrehajtásához.

Egységteszt létrehozása munkafolyamat-futtatásból

Nyissa meg a Standard logikai alkalmazás projektet a Visual Studio Code-ban.
A Visual Studio Code eszköztár Futtatás menüjében válassza a Hibakeresés indítása lehetőséget. (Billentyűzet: Nyomja le az F5 billentyűt)
Térjen vissza az Explorer ablakhoz. Bontsa ki a munkafolyamat-definíció mappát a projektben.
Nyissa meg a workflow.json helyi menüt, és válassza az Áttekintést.
Az áttekintési lapon, a Futtatási előzmények csoportban válassza ki az egységteszt létrehozásához használandó munkafolyamat-futtatás lehetőséget.
A futtatási előzmények eszköztárán válassza az Egységteszt létrehozása futtatásból lehetőséget.

Adjon meg egy nevet az egységteszthez, az egységteszt osztályhoz és a C# fájlhoz.

Az Explorer ablakban megjelenik egy Tesztek nevű új projektmappa a logikai alkalmazás projektmappájában. A Tesztek mappa a következő mappákat és fájlokat tartalmazza:

Mappa vagy fájl	Leírás
`Tests` \|\| <`logic-app-name`>	`Tests` A mappában megjelenik egy <`logic-app-name`> mappa, amikor egységteszteket ad hozzá egy logikai alkalmazásprojekthez.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`>	<`logic-app-name`> A mappában egy <`workflow-name`> mappa jelenik meg, amikor egységteszteket ad hozzá egy munkafolyamathoz.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| `MockOutputs` \|\|\|\|\|<`operation-name-outputs`>.`cs`	<`workflow-name`> A mappában egy C# (`MockOutputs`) fájl található, amely erősen gépelt osztályokat tartalmaz a munkafolyamat minden egyes összekötőműveletéhez. Minden .cs fájlnév a következő formátumot használja: < `operation-name` >[]`Trigger\\|ActionOutput.cs` Ha egy összekötő-művelet dinamikus szerződéssel rendelkezik, minden dinamikus típushoz megjelenik egy osztály. A dinamikus típus olyan műveleti paraméterre utal, amely különböző bemenetekkel és kimenetekkel rendelkezik az adott paraméterhez megadott érték alapján. Ezekkel az osztályokkal kibővítheti az egységteszteket, és új maketteket hozhat létre az alapoktól.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| <`unit-test-name`> \|\|\|\|\| <`unit-test-name`>`-mock.json` \|\|\|\|\| <`unit-test-name`>`.cs`	<`workflow-name`> A mappában a <`unit-test-name`> következő fájlok találhatók: – A <`unit-test-name`>`-mock.json` fájl JSON-reprezentációt tartalmaz a létrehozott makettekhez az egységtesztet létrehozó munkafolyamat-futtatás alapján. – A <`unit-test-name`>`.cs` fájl egy C# mintaosztályt és metódusokat tartalmaz, amelyek a *`-mock.json`** fájlt az eredmények futtatására és érvényesítésére használják. Ezt a fájlt úgy szerkesztheti, hogy megfeleljen az adott tesztforgatókönyveknek.

A *-mock.json fájl áttekintése

Ez a fájl a következő fő szakaszokat tartalmazza:

`triggerMocks` szakasz

A triggerMocks szakasz a munkafolyamat-eseményindítóból származó szimulált eredményt tartalmazza. Ez a szakasz szükséges a munkafolyamat-végrehajtás elindításához, ahogyan az a következő példában látható:

{
    "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` szakasz

A munkafolyamat-futtatás minden egyes utánozható műveletéhez a actionMocks szakasz egy szimulált műveletet tartalmaz, és garantálja a munkafolyamat szabályozott végrehajtását.

{
    "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": {}
            }
        }
    }
}

Az egységteszt *.cs fájljának áttekintése

Ez az egységtesztelő osztály keretrendszert biztosít a standard logikai alkalmazás munkafolyamatainak teszteléséhez triggerek és műveletek szimulálásával. Ez az osztály lehetővé teszi a munkafolyamatok tesztelését anélkül, hogy külső szolgáltatásokat vagy API-kat hívna meg.

Osztályszerkezet tesztelése

Egy tipikus egységtesztelő osztály a következő struktúrát használja:

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

Setup() metódus

Ez a módszer a TestExecutor osztályt példányosítja a tesztbeállítási konfigurációs fájl elérési útjának megadásával. A metódus minden egyes tesztvégrehajtás előtt fut, és létrehoz egy új példányt.TestExecutor

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

Mintatesztelési módszerek

Az alábbi szakasz az egységteszt osztályban használható mintatesztelési módszereket ismerteti.

Statikus modell adattesztje

Az alábbi módszer azt mutatja be, hogyan használhat statikus mintaadatokat a munkafolyamat teszteléséhez. Ebben a módszerben a következő feladatokat hajthatja végre:

Állítsa be a tulajdonságértékeket a szimulált műveleteken.
Hajtsa végre a munkafolyamatot a konfigurált mintaadatokkal.
Győződjön meg arról, hogy a végrehajtás sikeres volt.

[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);
}

Dinamikus modell adattesztje

Az alábbi módszer bemutatja, hogyan használhat dinamikus modelladatokat visszahívási módszerekkel. Ez a megközelítés két lehetőséget kínál, amelyek dinamikusan hoznak létre mintaadatokat:

Adjon meg egy külön visszahívási módszert.
Használjon beágyazott lambdafüggvényt.

Mindkét módszer lehetővé teszi, hogy dinamikus válaszokat hozzon létre az egységtesztek végrehajtási környezete alapján.

[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);
}

Hibaforgatókönyv-teszt

Az alábbi módszer bemutatja, hogyan tesztelheti a hibafeltételeket. Ebben a módszerben a következő feladatokat hajthatja végre:

Konfigurálja a szimulált műveleteket úgy, hogy adott hibakódokkal és üzenetekkel hiúsuljanak meg.
Ellenőrizze, hogy a munkafolyamat megfelelően kezeli-e ezeket a hibafeltételeket.

[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);
}

Segédmetenek

A következő szakasz a mintatesztelési módszerek által használt módszereket ismerteti. A segédmetenek az osztálydefiníció tesztelési módszerei alatt jelennek meg.

GetTestMockDefinition()

Az alábbi metódus betölti a modelldefiníciót egy JSON-fájlból. Ezt a módszert akkor szerkesztheti, ha a rendszer más helyen vagy formátumban tárolja a makettadatokat.

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));
}

Visszahívási módszer

Az alábbi módszer dinamikusan hoz létre mintaadatokat. A metódus neve a statikus vagy dinamikus mintaadatok tesztelési módszereiben szereplő szimulált műveletnévtől függően változik. Ezt a módszert úgy szerkesztheti, hogy a tesztforgatókönyv követelményei alapján különböző mintaválaszokat adjon vissza, vagy sablonként használhatja saját dinamikus visszahívási módszerek létrehozásához.

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

        }
    );
}

Egységtesztek létrehozása standard munkafolyamat-definíciókból az Azure Logic Appsben a Visual Studio Code használatával

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-06-09