Buat pengujian satuan dari pelaksanaan alur kerja standar di Azure Logic Apps dengan Visual Studio Code

Berlaku pada: Azure Logic Apps (Standar)

Pengujian unit adalah praktik penting yang membuat aplikasi atau solusi Anda tetap andal dan akurat sepanjang siklus hidup pengembangan perangkat lunak. Pengujian unit membantu Anda memvalidasi komponen utama dalam solusi Anda secara efisien dan sistematis.

Untuk alur kerja aplikasi logika Standar, Anda dapat membuat pengujian unit dengan menggunakan Visual Studio Code dan ekstensi Azure Logic Apps (Standar). Kemampuan ini memungkinkan Anda menggunakan eksekusi alur kerja yang dijalankan sebelumnya untuk membuat pengujian unit dan menyesuaikannya dengan skenario yang didukung oleh solusi aplikasi logika Anda. Pendekatan ini memberikan manfaat berikut:

Gunakan kembali eksekusi alur kerja untuk menghasilkan data tiruan untuk operasi tertentu dalam alur kerja.

Data ini memungkinkan Anda menguji alur kerja tanpa harus memanggil layanan, sistem, atau API eksternal. Anda menghemat waktu, dan alur kerja Anda tetap selaras dengan skenario eksekusi alur kerja aktual.
Tingkatkan kualitas alur kerja dengan mengidentifikasi dan mengatasi potensi masalah sebelum Anda menyebarkan ke lingkungan lain.
Permudah integrasi pengujian unit dengan proses pengembangan Anda, sekaligus memastikan perilaku alur kerja yang konsisten dan akurat.

Panduan ini menunjukkan cara membuat definisi pengujian unit dari pengoperasian alur kerja. Definisi ini meniru panggilan eksternal dari setiap operasi alur kerja tanpa mengubah logika alur kerja. Saat Anda membuat pengujian unit dari alur kerja yang dijalankan, Anda mendapatkan proyek pengujian unit yang menyertakan dua folder:

Folder yang berisi kelas yang diketik dengan kuat untuk setiap operasi yang dapat ditiru dalam alur kerja Anda.
Folder untuk setiap definisi pengujian unit, yang mencakup file berikut:
- File JSON yang mewakili operasi tiruan yang dihasilkan dalam alur kerja Anda.
- File C# yang berisi kelas sampel dan metode yang Anda gunakan untuk menyiapkan pernyataan Anda sendiri, mengonfirmasi bahwa alur kerja berperilaku seperti yang diharapkan, dan pastikan alur kerja berperilaku andal dan dapat diprediksi dalam ekosistem Azure Anda yang lebih besar.

Prasyarat

Akun dan langganan Azure. Jika Anda tidak memiliki langganan, daftar untuk mendapatkan akun Azure secara gratis.
Proyek aplikasi logika Standar di Visual Studio Code yang berisi setidaknya satu alur kerja yang dieksekusi sebelumnya dan dieksekusi secara lokal untuk digunakan untuk membuat pengujian unit.

Untuk informasi selengkapnya tentang penyiapan Visual Studio Code dan pembuatan proyek, lihat Membuat alur kerja aplikasi logika Standar dengan Visual Studio Code.

Batasan dan masalah yang diketahui

Rilis ini saat ini hanya mendukung C# untuk membuat pengujian unit.
Rilis ini tidak mendukung tindakan yang tidak ditidakan. Pastikan bahwa semua tindakan dalam proses eksekusi alur kerja diuji dengan simulasi.
Rilis ini tidak mendukung jenis tindakan berikut:
- Tindakan akun integrasi
- Tindakan Pemeta Data
- Tindakan kode kustom
- Tindakan XML
- Tindakan cair
- Tindakan pengodean dan dekode EDI

Tinjau konsep dasar

Daftar berikut ini mencakup konsep dasar tetapi penting tentang pengujian unit untuk alur kerja Standar:

Pengujian unit aplikasi logika

Eksekusi alur kerja terkontrol yang menyuntikkan objek tiruan. Objek ini mewakili pemicu alur kerja atau tindakan yang bergantung pada layanan atau sistem eksternal.
Tindakan yang dapat disimulasikan

Tindakan alur kerja yang bergantung pada layanan atau sistem eksternal. Anda dapat mengonversi aksi ini menjadi aksi tiruan untuk pembuatan dan eksekusi pengujian unit.

Membuat uji unit dari pelaksanaan alur kerja

Di Visual Studio Code, buka proyek aplikasi logika Standar Anda.
Pada toolbar Visual Studio Code, dari menu Jalankan, pilih Mulai Debugging. (Keyboard: Tekan F5)
Kembali ke jendela Explorer . Di proyek Anda, perluas folder definisi alur kerja.
Buka menu pintasan workflow.json , dan pilih Gambaran Umum.
Pada halaman gambaran umum, di bawah Jalankan riwayat, pilih alur kerja yang dijalankan untuk digunakan untuk membuat pengujian unit.
Pada toolbar riwayat eksekusi, pilih Buat pengujian unit dari eksekusi.

Berikan nama yang akan digunakan untuk pengujian unit, kelas pengujian unit, dan file C#.

Di jendela Explorer , folder proyek baru bernama Tests muncul di bawah folder proyek aplikasi logika Anda. Folder Pengujian berisi folder dan file berikut:

Folder atau file	Deskripsi
`Tests` \|\| <`logic-app-name`>	Di dalam folder `Tests`, folder <`logic-app-name`> akan muncul saat Anda menambahkan pengujian unit ke proyek aplikasi logika.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`>	<`logic-app-name`> Di folder, <`workflow-name`> folder muncul saat Anda menambahkan pengujian unit untuk alur kerja.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| `MockOutputs` \|\|\|\|\|<`operation-name-outputs`>.`cs`	Di dalam folder <`workflow-name`>, folder `MockOutputs` berisi file C# (.cs) dengan kelas yang bertipe kuat untuk setiap operasi konektor dalam alur kerja. Setiap nama file .cs menggunakan format berikut: < `operation-name` > `Trigger\\|Action`[]`Output.cs` Jika operasi konektor memiliki kontrak dinamis, kelas akan muncul untuk setiap jenis dinamis. Jenis dinamis mengacu pada parameter operasi yang memiliki input dan output yang berbeda berdasarkan nilai yang disediakan untuk parameter tersebut. Anda dapat menggunakan kelas-kelas ini untuk memperluas pengujian unit Anda dan membuat tiruan baru dari awal.
`Tests` \|\| <`logic-app-name`> \|\|\| <`workflow-name`> \|\|\|\| <`unit-test-name`> \|\|\|\|\| <`unit-test-name`>`-mock.json` \|\|\|\|\| <`unit-test-name`>`.cs`	Pada folder <`workflow-name`>, folder <`unit-test-name`> berisi file berikut: - File <`unit-test-name`>`-mock.json` berisi representasi JSON untuk mock yang dihasilkan, berdasarkan jalannya alur kerja yang membuat pengujian unit. - File <`unit-test-name`>`.cs` berisi contoh kelas C# dan metode yang menggunakan *`-mock.json`** file untuk menjalankan dan menegaskan hasil. Anda dapat mengedit file ini agar sesuai dengan skenario pengujian spesifik Anda.

Tinjau file *-mock.json

File ini memiliki bagian utama berikut:

`triggerMocks` bagian

Bagian triggerMocks berisi hasil simulasi dari pemicu alur kerja. Bagian ini diperlukan untuk memulai eksekusi alur kerja seperti yang ditunjukkan dalam contoh berikut:

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

Untuk setiap tindakan yang dapat ditiru dalam eksekusi alur kerja, bagian actionMocks berisi tindakan tiruan dan menjamin eksekusi alur kerja yang terkendali.

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

Tinjau pengujian unit *file .cs

Kelas pengujian unit ini menyediakan kerangka kerja untuk menguji alur kerja aplikasi logika Standar dengan meniru pemicu dan tindakan. Kelas ini memungkinkan Anda menguji alur kerja tanpa benar-benar memanggil layanan eksternal atau API.

Menguji struktur kelas

Kelas pengujian unit umum menggunakan struktur berikut:

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

Metode Setup()

Metode ini menginisialisasi kelas TestExecutor dengan menggunakan jalur ke file konfigurasi pengaturan tes Anda. Metode ini berjalan sebelum setiap eksekusi pengujian dan membuat instans baru TestExecutor.

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

Sampel metode pengujian

Bagian berikut menjelaskan metode pengujian sampel yang dapat Anda gunakan di kelas pengujian unit Anda.

Uji data tiruan statis

Metode berikut menunjukkan cara menggunakan data tiruan statis untuk menguji alur kerja Anda. Dalam metode ini, Anda dapat menyelesaikan tugas berikut:

Atur nilai properti pada tindakan tiruan Anda.
Jalankan alur kerja dengan data tiruan yang dikonfigurasi.
Konfirmasikan bahwa eksekusi berhasil.

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

Pengujian data tiruan dinamis

Metode berikut menunjukkan cara menggunakan data tiruan dinamis dengan metode panggilan balik. Pendekatan ini memberi Anda dua opsi yang secara dinamis menghasilkan data tiruan:

Tentukan metode panggilan balik terpisah.
Gunakan fungsi lambda sebaris.

Kedua pendekatan memungkinkan Anda membuat respons dinamis berdasarkan konteks eksekusi pengujian unit.

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

Pengujian skenario kesalahan

Metode berikut menunjukkan cara menguji kondisi kegagalan. Dalam metode ini, Anda dapat menyelesaikan tugas berikut:

Konfigurasikan tindakan tiruan agar gagal dengan kode kesalahan dan pesan tertentu.
Konfirmasikan bahwa alur kerja menangani kondisi kesalahan ini dengan benar.

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

Metode pembantu

Bagian berikut menjelaskan metode yang digunakan oleh metode pengujian sampel. Metode pembantu muncul di bawah metode pengujian dalam definisi kelas.

GetTestMockDefinition()

Metode berikut memuat definisi tiruan dari file JSON. Anda dapat mengedit metode ini jika data tiruan Anda disimpan di lokasi atau format yang berbeda.

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

Metode panggilan balik

Metode berikut secara dinamis menghasilkan data tiruan. Nama metode bervariasi berdasarkan nama tindakan yang ditiru dalam metode pengujian untuk data tiruan statis atau dinamis. Anda dapat mengedit metode ini untuk mengembalikan respons tiruan yang berbeda berdasarkan persyaratan skenario pengujian Anda atau menggunakannya sebagai templat untuk membuat metode panggilan balik dinamis Anda sendiri.

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

        }
    );
}

Membuat pengujian unit dari definisi alur kerja Standar di Azure Logic Apps dengan Visual Studio Code

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-06-09