Tartós függvények és tartós feladat SDK-k egységtesztje

A tartós vezénylések egységtesztelése segít az üzleti logika ellenőrzésében és a hibák korai észlelésében. A vezénylések több tevékenységet koordinálnak, és gyorsan összetettek lehetnek, így a tesztek védelmet nyújtanak a regressziók ellen a munkafolyamat fejlődésével.

Válassza ki a projektnek megfelelő lapot: Durable Functions ha Azure Functions használ, vagy Durable Task SDK-k ha az önálló SDK-t Azure Functions nélkül használja.

Durable Functions segítségével a vezénylőket, tevékenységeket és az ügyfél (trigger) függvényeket a keretrendszer által biztosított környezeti objektumok mokkolásával tesztelheti, és közvetlenül meghívhatja a függvényeket. Ez a módszer elkülöníti az üzleti logikát a Azure Functions futtatókörnyezettől.

Íme egy minimális C#-vezénylési teszt a minta megjelenítéséhez:

[Fact]
public async Task MyOrchestrator_CallsActivity()
{
    var contextMock = new Mock<TaskOrchestrationContext>();
    contextMock.Setup(x => x.CallActivityAsync<string>(
        It.IsAny<TaskName>(), It.IsAny<string>(), It.IsAny<TaskOptions>()))
        .ReturnsAsync("result");

    var result = await MyOrchestrator.Run(contextMock.Object);

    Assert.Equal("result", result);
}

A cikk további része részletesen ismerteti a C# és a Python mintáját.

A különálló Durable Task SDK-k beépített tesztinfrastruktúrát biztosítanak, amely külső függőségek nélkül futtat vezényléseket a memóriában. Orchesztrálókat és tevékenységeket regisztrálhat egy tesztmunkással, és ütemezheti az orchesztrálásokat tesztügyfél segítségével, valamint ellenőrizheti az eredményeket. A C# és a JavaScript esetében nem szükséges mockolás. Python generátoralapú megközelítést használ manuális eredményinjektálással.

Íme egy minimális C#-teszt a minta megjelenítéséhez:

[Fact]
public async Task MyOrchestrator_Completes()
{
    await using var host = await DurableTaskTestHost.StartAsync(tasks =>
    {
        tasks.AddOrchestrator<MyOrchestrator>();
        tasks.AddActivity<MyActivity>();
    });

    string id = await host.Client.ScheduleNewOrchestrationInstanceAsync(nameof(MyOrchestrator));
    var result = await host.Client.WaitForInstanceCompletionAsync(id, getInputsAndOutputs: true);

    Assert.Equal(OrchestrationRuntimeStatus.Completed, result.RuntimeStatus);
}

A cikk további része részletesen ismerteti ezt a mintát a C#, a Python és a JavaScript esetében.

Prerequisites

C#

• xUnit – tesztelési keretrendszer
• Moq — tesztkörnyezet szimuláló keretrendszer
• Az .NET izolált feldolgozómodell ismerete

Python

• Python unittest – tesztelési keretrendszer
• unittest.mock – mocking library
• A Python v2 programozási modell ismerete

JavaScript

Az Durable Functions JavaScript-egységteszteléséhez különálló Durable Task SDK szükséges. Váltson a lap tetején található Durable Task SDKs lapra a beépített tesztinfrastruktúrával rendelkező JavaScript-tesztelési példákhoz.

C#

• xUnit – tesztelési keretrendszer
• A Microsoft.DurableTask.InProcessTestHost NuGet-csomag (1.0.0-s vagy újabb verzió)

Python

• pytest – tesztelési keretrendszer (vagy unittest)
• A durabletask PyPI-csomag

JavaScript

• Jest – tesztelési keretrendszer
• Az @microsoft/durabletask-js npm-csomag

Orchestrátorfüggvények tesztelése

Az Orchestrator függvények koordinálják a tevékenységeket, az időzítőket és a külső eseményeket. Ezek általában a legtöbb üzleti logikát tartalmazzák, és a legtöbbet ki tudják használni az egységtesztelésből.

Szimulálja az orkesztációs környezetet a tevékenységhívások visszatérési értékeinek vezérlésére. Ezután hívja meg közvetlenül a vezénylőt, és ellenőrizze a kimenetet.

C#

Fontolja meg ezt az orchestrator-t, amely háromszor hív meg egy tevékenységet:

[Function(nameof(HelloCitiesOrchestration))]
public static async Task<List<string>> HelloCities(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    var outputs = new List<string>
    {
        await context.CallActivityAsync<string>(nameof(SayHello), "Tokyo"),
        await context.CallActivityAsync<string>(nameof(SayHello), "Seattle"),
        await context.CallActivityAsync<string>(nameof(SayHello), "London")
    };

    return outputs;
}

A Moq használatával szimulálhatja TaskOrchestrationContext és beállíthatja az egyes tevékenységhívások várható visszatérési értékeit.

Note

A It.Is<TaskName>(...) minta azért szükséges, mert CallActivityAsync nem egyszerű sztringet, hanem szerkezetet fogad el TaskName . A Moq-nak szüksége van explicit típusegyezésre.

[Fact]
public async Task HelloCities_ReturnsExpectedGreetings()
{
    var contextMock = new Mock<TaskOrchestrationContext>();

    // Mock each activity call to return a known value
    contextMock.Setup(x => x.CallActivityAsync<string>(
        It.Is<TaskName>(n => n.Name == nameof(SayHello)),
        It.Is<string>(n => n == "Tokyo"),
        It.IsAny<TaskOptions>())).ReturnsAsync("Hello Tokyo!");

    contextMock.Setup(x => x.CallActivityAsync<string>(
        It.Is<TaskName>(n => n.Name == nameof(SayHello)),
        It.Is<string>(n => n == "Seattle"),
        It.IsAny<TaskOptions>())).ReturnsAsync("Hello Seattle!");

    contextMock.Setup(x => x.CallActivityAsync<string>(
        It.Is<TaskName>(n => n.Name == nameof(SayHello)),
        It.Is<string>(n => n == "London"),
        It.IsAny<TaskOptions>())).ReturnsAsync("Hello London!");

    var result = await HelloCitiesOrchestration.HelloCities(contextMock.Object);

    Assert.Equal(3, result.Count);
    Assert.Equal("Hello Tokyo!", result[0]);
    Assert.Equal("Hello Seattle!", result[1]);
    Assert.Equal("Hello London!", result[2]);
}

Python

Fontolja meg ezt a vezénylőt, amely három tevékenységhívást bonyolít le:

import azure.durable_functions as df

def my_orchestrator(context: df.DurableOrchestrationContext):
    result1 = yield context.call_activity("say_hello", "Tokyo")
    result2 = yield context.call_activity("say_hello", "Seattle")
    result3 = yield context.call_activity("say_hello", "London")
    return [result1, result2, result3]

Szimulálja a környezetet, és használja orchestrator_generator_wrapper a generátor feldolgozására.

Note

A Azure Durable Functions SDK orchestrator_generator_wrapper biztosít a Python vezénylőgenerátorokat meghajtó visszajátszási mechanizmus szimulálásához. Az önálló Durable Task SDK nem tartalmazza ezt a segédprogramot, ezért a Durable Task SDKs lap ehelyett manuális gen.send() hívásokat használ.

import unittest
from unittest.mock import Mock, call
from azure.durable_functions.testing import orchestrator_generator_wrapper

from function_app import my_orchestrator


def mock_activity(activity_name, input_value):
    mock_task = Mock()
    mock_task.result = f"Hello {input_value}!"
    return mock_task


class TestOrchestrator(unittest.TestCase):
    def test_chaining_orchestrator(self):
        # Extract the raw orchestrator function from the Azure Functions decorator wrapper
        func_call = my_orchestrator.build().get_user_function().orchestrator_function

        context = Mock()
        context.call_activity = Mock(side_effect=mock_activity)

        user_orchestrator = func_call(context)
        values = list(orchestrator_generator_wrapper(user_orchestrator))

        expected_calls = [
            call("say_hello", "Tokyo"),
            call("say_hello", "Seattle"),
            call("say_hello", "London"),
        ]
        self.assertEqual(context.call_activity.call_args_list, expected_calls)
        self.assertEqual(values[-1], ["Hello Tokyo!", "Hello Seattle!", "Hello London!"])

JavaScript

JavaScript-egységteszteléshez váltson a lap tetején található Durable Task SDKs lapra.

C#

Az DurableTaskTestHost használható az orchestrációk memóriabeli futtatására. Regisztrálja a produkciós vezénylőt és a tevékenységi osztályokat, ütemezze a vezénylést, és ellenőrizze az eredményt.

Ezeket a termelési osztályokat figyelembe véve:

class HelloCitiesOrchestrator : TaskOrchestrator<string, List<string>>
{
    public override async Task<List<string>> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        var outputs = new List<string>
        {
            await context.CallActivityAsync<string>(nameof(SayHelloActivity), "Tokyo"),
            await context.CallActivityAsync<string>(nameof(SayHelloActivity), "Seattle"),
            await context.CallActivityAsync<string>(nameof(SayHelloActivity), "London")
        };
        return outputs;
    }
}

class SayHelloActivity : TaskActivity<string, string>
{
    public override Task<string> RunAsync(TaskActivityContext context, string name)
    {
        return Task.FromResult($"Hello {name}!");
    }
}

Regisztrálja őket közvetlenül a teszthelygépen:

[Fact]
public async Task HelloCities_ReturnsExpectedGreetings()
{
    await using var host = await DurableTaskTestHost.StartAsync(tasks =>
    {
        tasks.AddOrchestrator<HelloCitiesOrchestrator>();
        tasks.AddActivity<SayHelloActivity>();
    });

    string instanceId = await host.Client.ScheduleNewOrchestrationInstanceAsync(
        nameof(HelloCitiesOrchestrator));
    OrchestrationMetadata result = await host.Client.WaitForInstanceCompletionAsync(
        instanceId, getInputsAndOutputs: true);

    Assert.Equal(OrchestrationRuntimeStatus.Completed, result.RuntimeStatus);

    var output = result.ReadOutputAs<List<string>>();
    Assert.Equal(3, output.Count);
    Assert.Equal("Hello Tokyo!", output[0]);
    Assert.Equal("Hello Seattle!", output[1]);
    Assert.Equal("Hello London!", output[2]);
}

DurableTaskTestHost egy teljes mértékben memóriában futó vezénylési motort futtat. Nincs szükség külső szolgáltatásokra vagy kiegészítő folyamatokra.

Python

A Python Durable Task SDK még nem biztosít olyan beépített tesztköteget, mint a C# és a JavaScript. Használjon szabványos mockolást az orchestrátor logika teszteléséhez. A szimulált tevékenység eredményeinek visszaküldésével kijátsszon OrchestrationContext egy generátort, és vezesse a generátort.yield

Note

A Azure Durable Functions SDK-val ellentétben (amely orchestrator_generator_wrapper biztosít), a különálló Durable Task SDK-hoz manuálisan kell előrelépnie a generátort gen.send(). Így explicit módon szabályozhatja a szimulált tevékenység eredményeit.

from unittest.mock import Mock, call
from durabletask import task


def hello(ctx: task.ActivityContext, name: str) -> str:
    return f"Hello {name}!"


def hello_cities(ctx: task.OrchestrationContext, _):
    result1 = yield ctx.call_activity(hello, input="Tokyo")
    result2 = yield ctx.call_activity(hello, input="Seattle")
    result3 = yield ctx.call_activity(hello, input="London")
    return [result1, result2, result3]


def test_hello_cities():
    ctx = Mock(spec=task.OrchestrationContext)

    # Each call_activity returns a mock task; collect them to send results back
    mock_tasks = []
    def fake_call_activity(activity, *, input):
        t = Mock()
        t._input = input
        mock_tasks.append(t)
        return t

    ctx.call_activity = Mock(side_effect=fake_call_activity)

    # Start the generator
    gen = hello_cities(ctx, None)
    yielded = next(gen)  # first yield: call_activity(hello, input="Tokyo")

    # Send simulated results back for each yield
    try:
        yielded = gen.send("Hello Tokyo!")
        yielded = gen.send("Hello Seattle!")
        gen.send("Hello London!")
    except StopIteration as e:
        result = e.value

    # Verify the orchestrator called the right activities
    assert ctx.call_activity.call_count == 3
    assert result == ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]

Ez a megközelítés az SDK belső elemeitől függetlenül teszteli a vezénylő vezérlési folyamatát.

JavaScript

TestOrchestrationWorker és TestOrchestrationClient használata vezénylések memóriában történő futtatásához:

const {
    InMemoryOrchestrationBackend,
    TestOrchestrationClient,
    TestOrchestrationWorker,
    OrchestrationStatus,
} = require("@microsoft/durabletask-js");

test("helloCities returns expected greetings", async () => {
    const backend = new InMemoryOrchestrationBackend();
    const client = new TestOrchestrationClient(backend);
    const worker = new TestOrchestrationWorker(backend);

    const sayHello = async (_, name) => `Hello ${name}!`;

    const helloCities = async function* (ctx) {
        const outputs = [];
        outputs.push(yield ctx.callActivity(sayHello, "Tokyo"));
        outputs.push(yield ctx.callActivity(sayHello, "Seattle"));
        outputs.push(yield ctx.callActivity(sayHello, "London"));
        return outputs;
    };

    worker.addOrchestrator(helloCities);
    worker.addActivity(sayHello);
    await worker.start();

    const id = await client.scheduleNewOrchestration(helloCities);
    const state = await client.waitForOrchestrationCompletion(id, true, 10);

    expect(state.runtimeStatus).toEqual(OrchestrationStatus.COMPLETED);
    expect(JSON.parse(state.serializedOutput)).toEqual([
        "Hello Tokyo!",
        "Hello Seattle!",
        "Hello London!",
    ]);

    await worker.stop();
});

A tesztinfrastruktúra a teljes orchestration engine-t folyamati szinten futtatja. Nincs szükség oldalkocsira vagy külső szolgáltatásokra.

Tevékenységfüggvények tesztelése

A tevékenységfüggvények tartalmazzák a tényleges munkát – API-k meghívását, adatok feldolgozását vagy külső rendszerekkel való interakciót. Ezek a legegyszerűbben tesztelendő függvénytípusok, mivel nem rendelkeznek keretrendszerspecifikus visszajátszási viselkedésekkel.

C#

A Azure Functions tevékenységfüggvényei bemenetet kapnak, és opcionálisan egy FunctionContext. Tesztelje őket, mint bármely más függvényt:

[Function(nameof(SayHello))]
public static string SayHello(
    [ActivityTrigger] string name, FunctionContext executionContext)
{
    return $"Hello {name}!";
}

[Fact]
public void SayHello_ReturnsExpectedGreeting()
{
    var result = HelloCitiesOrchestration.SayHello("Tokyo", Mock.Of<FunctionContext>());
    Assert.Equal("Hello Tokyo!", result);
}

Python

A Azure Functions tevékenységfüggvényei rendszeres Python függvények. Tesztelje őket közvetlenül. További információ: Azure Functions Python egységtesztelés.

def say_hello(name: str) -> str:
    return f"Hello {name}!"

def test_say_hello():
    result = say_hello("Tokyo")
    assert result == "Hello Tokyo!"

JavaScript

JavaScript-tevékenységteszteléshez váltson a lap tetején található Durable Task SDKs lapra.

A tevékenységfüggvények környezeti objektumot és bemenetet kapnak. A környezet olyan metaadatokat biztosít, mint a vezénylési azonosító és a feladatazonosító, de a legtöbb tesztnek nincs rá szüksége.

C#

SayHelloActivity A vezénylői példa osztályának használatával közvetlenül hívjon RunAsync meg egy példakörnyezetet:

[Fact]
public async Task SayHello_ReturnsExpectedGreeting()
{
    var activity = new SayHelloActivity();
    var contextMock = new Mock<TaskActivityContext>();

    var result = await activity.RunAsync(contextMock.Object, "Tokyo");

    Assert.Equal("Hello Tokyo!", result);
}

Ha használja DurableTaskTestHost, a tevékenységek a vezénylési teszt részeként is futnak. Nincs szükség külön tevékenységtesztre, kivéve, ha a tevékenység összetett logikával rendelkezik.

Python

A tevékenységfüggvény közvetlen tesztelése – nincs szükség speciális beállításra:

from durabletask import task


def hello(ctx: task.ActivityContext, name: str) -> str:
    return f"Hello {name}!"


def test_hello():
    ctx = Mock(spec=task.ActivityContext)
    result = hello(ctx, "Tokyo")
    assert result == "Hello Tokyo!"

JavaScript

A feladatfüggvény közvetlen tesztelése:

const sayHello = async (_, name) => `Hello ${name}!`;

test("sayHello returns expected greeting", async () => {
    const result = await sayHello(undefined, "Tokyo");
    expect(result).toBe("Hello Tokyo!");
});

Az ügyfél programfunkcióinak tesztelése

Az ügyfélfüggvények (más néven triggerfüggvények) elindítják a vezényléseket, és kezelik a példányokat. A tartós ügyfélkapcsolatot használják, hogy kapcsolatba lépjenek a vezénylési motorral.

C#

Vegye tekintetbe ezt az HTTP-eseményindítót, amely folyamatvezérlést indít el.

[Function("HelloCitiesOrchestration_HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext executionContext)
{
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
        nameof(HelloCitiesOrchestration));
    return await client.CreateCheckStatusResponseAsync(req, instanceId);
}

Mock DurableTaskClient a jól ismert példányazonosító visszaadásához:

[Fact]
public async Task HttpStart_ReturnsAccepted()
{
    var durableClientMock = new Mock<DurableTaskClient>("testClient");
    var functionContextMock = new Mock<FunctionContext>();
    var instanceId = "test-instance-id";

    durableClientMock
        .Setup(x => x.ScheduleNewOrchestrationInstanceAsync(
            It.IsAny<TaskName>(),
            It.IsAny<object>(),
            It.IsAny<StartOrchestrationOptions>(),
            It.IsAny<CancellationToken>()))
        .ReturnsAsync(instanceId);

    var mockRequest = CreateMockHttpRequest(functionContextMock.Object);

    var responseMock = new Mock<HttpResponseData>(functionContextMock.Object);
    responseMock.SetupGet(r => r.StatusCode).Returns(HttpStatusCode.Accepted);

    durableClientMock
        .Setup(x => x.CreateCheckStatusResponseAsync(
            It.IsAny<HttpRequestData>(),
            It.IsAny<string>(),
            It.IsAny<CancellationToken>()))
        .ReturnsAsync(responseMock.Object);

    var result = await HelloCitiesOrchestration.HttpStart(
        mockRequest, durableClientMock.Object, functionContextMock.Object);

    Assert.Equal(HttpStatusCode.Accepted, result.StatusCode);
}

Python

Vegye tekintetbe ezt az HTTP-eseményindítót, amely folyamatvezérlést indít el.

@app.route(route="start")
@app.durable_client_input(client_name="client")
async def http_start(req: func.HttpRequest, client):
    instance_id = await client.start_new("my_orchestrator")
    return client.create_check_status_response(req, instance_id)

A tartós kliens szimulálása:

import asyncio
import unittest
import azure.functions as func
from unittest.mock import AsyncMock, Mock

from function_app import http_start


class TestClientFunction(unittest.TestCase):
    def test_http_start(self):
        # Extract the raw client function from the Azure Functions decorator wrapper
        func_call = http_start.build().get_user_function().client_function

        req = func.HttpRequest(
            method="GET",
            body=b"{}",
            url="/api/start",
        )

        client = Mock()
        client.start_new = AsyncMock(return_value="test-instance-id")
        client.create_check_status_response = Mock(return_value="check_status_response")

        result = asyncio.run(func_call(req, client))

        client.start_new.assert_called_once_with("my_orchestrator")
        client.create_check_status_response.assert_called_once_with(req, "test-instance-id")

JavaScript

JavaScript-ügyfélteszteléshez váltson a lap tetején található Durable Task SDK-k lapra.

Ügyfélműveletek tesztelése

Önálló Durable Task SDK-k esetén az ügyfélműveletek (vezénylések ütemezése, állapot lekérdezése, események kiváltása) ugyanazt használják, mint TestOrchestrationClient a vezénylő tesztekben. Nincs külön ügyfélfüggvény – közvetlenül meghívja az ügyfél API-t.

C#

DurableTaskTestHost host.Clientteszi elérhetővé , ami egy teljesen működőképes DurableTaskClient. Használatával tesztelheti az ügyfélszintű műveleteket, például az ütemezést, a lekérdezést vagy a vezénylések leállítását:

[Fact]
public async Task Client_CanQueryOrchestrationStatus()
{
    await using var host = await DurableTaskTestHost.StartAsync(tasks =>
    {
        tasks.AddOrchestrator<HelloCitiesOrchestrator>();
        tasks.AddActivity<SayHelloActivity>();
    });

    string instanceId = await host.Client.ScheduleNewOrchestrationInstanceAsync(
        nameof(HelloCitiesOrchestrator));

    // Query status while the orchestration runs
    OrchestrationMetadata metadata = await host.Client.WaitForInstanceCompletionAsync(
        instanceId, getInputsAndOutputs: true);

    Assert.Equal(OrchestrationRuntimeStatus.Completed, metadata.RuntimeStatus);
    Assert.Equal(instanceId, metadata.InstanceId);
}

Python

A Python Durable Task SDK még nem biztosít beépített tesztügyfélt. Tesztelje az ügyfélszintű logikát (ütemezés, lekérdezés) a TaskHubGrpcClient szimulálásával.

from unittest.mock import AsyncMock, Mock


def test_schedule_orchestration():
    client = Mock()
    client.schedule_new_orchestration = AsyncMock(return_value="test-id")

    # Call your application code that uses the client
    import asyncio
    instance_id = asyncio.run(client.schedule_new_orchestration("my_orchestrator"))

    assert instance_id == "test-id"
    client.schedule_new_orchestration.assert_called_once_with("my_orchestrator")

JavaScript

TestOrchestrationClient ugyanazokat a műveleteket támogatja, mint a termelési kliens. Ezzel tesztelheti az ütemezést, az állapot lekérdezéseket és az eseménynövelést:

const {
    InMemoryOrchestrationBackend,
    TestOrchestrationClient,
    TestOrchestrationWorker,
    OrchestrationStatus,
} = require("@microsoft/durabletask-js");

test("client can schedule and query orchestration", async () => {
    const backend = new InMemoryOrchestrationBackend();
    const client = new TestOrchestrationClient(backend);
    const worker = new TestOrchestrationWorker(backend);

    const myOrchestrator = async function* (ctx) {
        return "done";
    };

    worker.addOrchestrator(myOrchestrator);
    await worker.start();

    const id = await client.scheduleNewOrchestration(myOrchestrator);
    const state = await client.waitForOrchestrationCompletion(id, true, 10);

    expect(state.runtimeStatus).toEqual(OrchestrationStatus.COMPLETED);
    expect(JSON.parse(state.serializedOutput)).toBe("done");

    await worker.stop();
});

Kapcsolódó tartalom

• Durable Functions áttekintése
• Az Orchestrator függvénykódjának korlátozásai
• Migrálás a folyamatból izolált munkavállalóra (.NET)
• Sorosítás és állandóság a Durable Functions

• Mi az a tartós feladat?
• Az Orchestrator függvénykódjának korlátozásai
• Fejlesztés a Durable Task Schedulerrel