Eenheidstest Durable Functions en Duurzame taak-SDK's

Met unit tests voor duurzame orkestraties kunt u de bedrijfslogica verifiëren en fouten vroegtijdig opsporen. Indelingen coördineren meerdere activiteiten en kunnen snel complex worden, dus tests beschermen tegen regressies naarmate uw werkstroom zich ontwikkelt.

Selecteer het tabblad dat overeenkomt met uw project: Durable Functions als u Azure Functions gebruikt of Urable Task SDK's als u de zelfstandige SDK zonder Azure Functions gebruikt.

Met Durable Functions test je orchestrators, activiteiten en clientfuncties (triggers) door de door het framework geleverde contextobjecten te simuleren en je functies direct aan te roepen. Deze benadering isoleert uw bedrijfslogica van de Azure Functions runtime.

Hier volgt een minimale C#-orchestratortest om het patroon weer te geven:

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

In de rest van dit artikel wordt dit patroon uitgebreid beschreven voor C# en Python.

De zelfstandige Durable Task SDK's bieden een ingebouwde testinfrastructuur waarmee indelingen in het geheugen worden uitgevoerd zonder externe afhankelijkheden. U registreert orchestrators en activiteiten bij een testmedewerker, plant indelingen via een testclient en bevestigt de resultaten. Er is geen mocking vereist voor C# en JavaScript. Python maakt gebruik van een op generator gebaseerde benadering met handmatige resultaatinjectie.

Hier volgt een minimale C#-test om het patroon weer te geven:

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

In de rest van dit artikel wordt dit patroon uitgebreid beschreven voor C#, Python en JavaScript.

Vereiste voorwaarden

xUnit — testframework
Moq — framework voor mocken (simuleren van softwarecomponenten)
Bekendheid met het .NET geïsoleerd werkermodel

xUnit — testframework
Het Microsoft.DurableTask.InProcessTestHost NuGet-pakket (v1.0.0 of hoger)

Het testen van de orchestratorfunctionaliteit

Orchestrator-functies coördineren activiteiten, timers en externe gebeurtenissen. Ze bevatten doorgaans de meeste bedrijfslogica en profiteren het meeste van eenheidstests.

Simuleer de orkestratiecontext om de retourwaarden van activiteitsoproepen te besturen. Roep vervolgens uw orchestrator rechtstreeks aan en controleer de uitvoer.

Houd rekening met deze orchestrator die drie keer een activiteit aanroept:

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

Gebruik Moq om TaskOrchestrationContext te mocken en verwachte retourwaarden in te stellen voor elke activiteitsoproep.

Note

Het It.Is<TaskName>(...) patroon is vereist omdat CallActivityAsync een TaskName struct accepteert, geen gewone tekenreeks. Moq heeft een expliciete typematch nodig.

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

Houd rekening met deze orchestrator die drie activiteitsoproepen koppelt:

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]

Simuleer de context en gebruik orchestrator_generator_wrapper om de generator te verwerken.

Note

De Azure Durable Functions SDK biedt orchestrator_generator_wrapper om het replay-mechanisme te simuleren dat Python orchestratorgeneratoren aanstuurt. De zelfstandige Durable Task SDK bevat dit hulpprogramma niet, dus het tabblad Durable Task SDK's maakt gebruik van handmatige gen.send() aanroepen.

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!"])

Gebruik DurableTaskTestHost om orkestraties in het geheugen uit te voeren. Registreer uw productie-orchestrator- en activiteitsklassen, plan een orkestratie en valideer het resultaat.

Gezien deze productieklassen:

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

Registreer ze rechtstreeks in de testhost:

[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 voert een complete in-memory orkestratie-engine uit. Er zijn geen externe services of sidecar-processen vereist.

De Python Durable Task SDK biedt nog geen ingebouwde testharnas zoals C# en JavaScript. Gebruik standaard mocking om orchestrator-logica te testen. OrchestrationContext De generator simuleren en aansturen door gesimuleerde activiteitsresultaten voor elke yieldactiviteit te verzenden.

Note

In tegenstelling tot de Azure Durable Functions SDK (die orchestrator_generator_wrapper biedt), moet u voor de zelfstandige Durable Task SDK de generator handmatig voortzetten met gen.send(). Hiermee hebt u expliciet controle over de resultaten van de gesimuleerde activiteit.

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!"]

Met deze methode wordt de besturingsstroom van de orchestrator getest zonder afhankelijk te zijn van de interne SDK-functies.

Gebruik TestOrchestrationWorker en TestOrchestrationClient om orchestraties in het geheugen uit te voeren.

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

De testinfrastructuur voert de volledige indelingsengine in het proces uit. Er zijn geen sidecar- of externe services vereist.

Testactiviteitsfuncties

Activiteitsfuncties bevatten de werkelijke hoeveelheid werk, het aanroepen van API's, het verwerken van gegevens of het werken met externe systemen. Ze zijn het eenvoudigste functietype om te testen omdat ze geen frameworkspecifiek herhalingsgedrag hebben.

Activiteitsfuncties in Azure Functions ontvangen een invoer en eventueel een FunctionContext. Test ze net als elke andere functie:

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

Activiteitsfuncties in Azure Functions zijn reguliere Python functies. Test ze rechtstreeks. Zie Azure Functions Python eenheid testen voor meer informatie.

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

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

Activiteitsfuncties ontvangen een contextobject en invoer. De context biedt metagegevens zoals de indelings-id en taak-id, maar de meeste tests hebben deze niet nodig.

Gebruik de SayHelloActivity-klasse uit het orchestrator-voorbeeld om RunAsync direct aan te roepen met een mock-context:

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

Wanneer u DurableTaskTestHost gebruikt, worden activiteiten ook uitgevoerd als onderdeel van de orkestratietest. U hebt geen afzonderlijke activiteitstests nodig, tenzij de activiteit complexe logica heeft.

Test de activiteitsfunctie rechtstreeks: er is geen speciale installatie vereist:

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!"

Test de activiteitsfunctie rechtstreeks:

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

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

Testen van clientfuncties

Clientfuncties (ook wel triggerfuncties genoemd) starten orkestraties en beheren instanties. Ze gebruiken de duurzame clientbinding om te communiceren met de orchestration-engine.

Overweeg deze HTTP-trigger die een orchestratie start:

[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 om een bekende instance-ID te retourneren:

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

Overweeg deze HTTP-trigger die een orchestratie start:

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

Simuleer de duurzame client

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

Clientbewerkingen testen

Met de standalone Durable Task SDK's gebruiken clientbewerkingen (orchestraties plannen, status opvragen, gebeurtenissen afhandelen) hetzelfde TestOrchestrationClient als in de orchestratortests. Er bestaat geen afzonderlijke clientfunctie. U roept de client-API rechtstreeks aan.

DurableTaskTestHost introduceert host.Client, wat een volledig functioneel DurableTaskClient is. Gebruik deze om bewerkingen op clientniveau te testen, zoals inplannen, het uitvoeren van query's of beëindigen van orkestraties.

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

De Python Durable Task SDK biedt nog geen ingebouwde testclient. Test logica op clientniveau (planning, query's) door het TaskHubGrpcClientvolgende te bespotten:

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

TestOrchestrationClient ondersteunt dezelfde bewerkingen als de productieclient. Gebruik deze om planning, statusquery's en gebeurtenisverhoging te testen:

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

Feedback

Is deze pagina nuttig?

Last updated on 2026-04-28

Eenheidstest Durable Functions en Duurzame taak-SDK's

Vereiste voorwaarden

Het testen van de orchestratorfunctionaliteit

Testactiviteitsfuncties

Testen van clientfuncties

Clientbewerkingen testen

Verwante inhoud

Feedback

Aanvullende resources