Enhetstest för Durable Functions och Durable Task SDK:er

Enhetstestning av varaktiga orkestreringar hjälper dig att verifiera affärslogik och fånga fel tidigt. Orkestreringar samordnar flera aktiviteter och kan växa komplext snabbt, så tester skyddar mot regressioner när arbetsflödet utvecklas.

Välj den flik som matchar projektet: Durable Functions om du använder Azure Functions eller Durable Task SDK:er om du använder fristående SDK utan Azure Functions.

Med Durable Functions testar du orkestreringsfunktioner, aktiviteter och klientfunktioner (utlösare) genom att mocka ramverkstillhandahållna kontextobjekt och anropa dina funktioner direkt. Den här metoden isolerar din affärslogik från Azure Functions runtime.

Här är ett minimalt C#-orkestreringstest för att visa mönstret:

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

Resten av den här artikeln beskriver det här mönstret i detalj för C# och Python.

De fristående Durable Task SDK:erna tillhandahåller inbyggd testinfrastruktur som kör orkestreringar i minnet utan externa beroenden. Du registrerar orkestratorer och aktiviteter med en testarbetare, schemalägger orkestreringar via en testklient och bekräftar resultatet. Inget hån krävs för C# och JavaScript. Python använder en generatorbaserad metod med manuell resultatinmatning.

Här är ett minimalt C#-test för att visa mönstret:

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

Resten av den här artikeln beskriver det här mönstret i detalj för C#, Python och JavaScript.

Förutsättningar

xUnit – testramverk
Moq – testverktyg för simulering
Kunskaper om .NET isolerad arbetsmodell

xUnit – testramverk
NuGet-paketet Microsoft.DurableTask.InProcessTestHost (v1.0.0 eller senare)

Testa orkestratorfunktioner

Orchestrator-funktioner samordnar aktiviteter, timers och externa händelser. De innehåller vanligtvis mest affärslogik och drar mest nytta av enhetstestning.

Håna orkestreringskontexten för att kontrollera returvärdena för aktivitetsanrop. Anropa sedan orkestratorn direkt och verifiera utdata.

Tänk på den här orkestratorn som anropar en aktivitet tre gånger:

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

Använd Moq för att mocka TaskOrchestrationContext och konfigurera förväntade returvärden för varje aktivitetsanrop.

Note

Mönstret It.Is<TaskName>(...) krävs eftersom CallActivityAsync accepterar en TaskName struct, inte en vanlig sträng. Moq behöver den explicita typmatchningen.

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

Tänk på den här orkestratorn som kedjar tre aktivitetsanrop:

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]

Simulera kontexten och använd orchestrator_generator_wrapper för att bearbeta generatorn.

Note

Azure Durable Functions SDK tillhandahåller orchestrator_generator_wrapper för att simulera reprismekanismen som kör Python orchestrator-generatorer. Fristående Durable Task SDK innehåller inte det här verktyget, så fliken Durable Task SDK:er använder manuella gen.send() anrop i stället.

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

Använd DurableTaskTestHost för att köra orkestreringar i minnet. Registrera dina produktionsorkestrator- och aktivitetsklasser, schemalägg en orkestrering och verifiera resultatet.

Med tanke på dessa produktionsklasser:

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

Registrera dessa objekt direkt i testmiljön:

[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 kör en komplett orkestreringsmotor i minnet. Inga externa tjänster eller sidoprocesser krävs.

Python Durable Task SDK tillhandahåller ännu inte någon inbyggd testsele som C# och JavaScript. Använd standardmockning för att testa orchestrator-logik. Simulera och kör generatorn genom att skicka tillbaka simulerade aktivitetsresultat för varje yield.

Note

Till skillnad från Azure Durable Functions SDK (som tillhandahåller orchestrator_generator_wrapper) kräver fristående Durable Task SDK att du manuellt avancerar generatorn med gen.send(). Detta ger dig explicit kontroll över de simulerade aktivitetsresultaten.

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

Den här metoden testar orkestratorns kontrollflöde utan att vara beroende av SDK:s interna funktioner.

Använd TestOrchestrationWorker och TestOrchestrationClient för att köra orkestreringar i minnet:

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

Testinfrastrukturen kör hela orkestreringsmotorn i processen. Inga sidovagns- eller externa tjänster krävs.

Testa aktivitetsfunktioner

Aktivitetsfunktioner innehåller det faktiska arbetet – anropa API:er, bearbeta data eller interagera med externa system. De är den enklaste funktionstypen att testa eftersom de inte har något ramverksspecifikt uppspelningsbeteende.

Aktivitetsfunktioner i Azure Functions tar emot indata och eventuellt en FunctionContext. Testa dem som andra funktioner:

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

Aktivitetsfunktioner i Azure Functions är vanliga Python funktioner. Testa dem direkt. Mer information finns i Azure Functions Python enhetstestning.

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

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

Aktivitetsfunktioner tar emot ett kontextobjekt och indata. Kontexten innehåller metadata som orkestrerings-ID och uppgifts-ID, men de flesta tester behöver det inte.

Med hjälp av SayHelloActivity klassen från orchestrator-exemplet anropar du RunAsync direkt med en falsk kontext:

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

När du använder DurableTaskTestHostkörs aktiviteter också som en del av orkestreringstestet. Du behöver inte separata aktivitetstester om inte aktiviteten har komplex logik.

Testa aktivitetsfunktionen direkt – ingen särskild installation krävs:

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

Testa aktivitetsfunktionen direkt:

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

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

Testa klientfunktioner

Klientfunktioner (kallas även utlösarfunktioner) startar orkestreringar och hanterar instanser. De använder den hållbara klientbindningen för att interagera med orkestreringsmotorn.

Tänk på den här HTTP-utlösaren som startar en orkestrering:

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

Mocka DurableTaskClient för att returnera ett känt instans-ID.

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

Tänk på den här HTTP-utlösaren som startar en orkestrering:

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

Håna den hållbara klienten:

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

Testa klientåtgärder

Med fristående Durable Task SDK:er använder klientåtgärder (schemaläggning av orkestreringar, frågestatus, trigga händelser) samma TestOrchestrationClient som redan visas i orchestrator-testerna. Det finns ingen separat klientfunktion – du anropar klient-API:et direkt.

DurableTaskTestHost visar host.Client, som är en fullt fungerande DurableTaskClient. Använd den för att testa åtgärder på klientnivå såsom schemaläggning, frågehantering eller att avsluta orkestreringar.

[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 Durable Task SDK tillhandahåller ännu inte någon inbyggd testklient. Testa logik på klientnivå (schemaläggning, frågor) genom att mocka TaskHubGrpcClient:

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 stöder samma åtgärder som produktionsklienten. Använd den för att testa schemaläggning, statusfrågor och händelsehöjning:

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

Var den här sidan till hjälp?

Last updated on 2026-04-28

Enhetstest för Durable Functions och Durable Task SDK:er

Förutsättningar

Testa orkestratorfunktioner

Testa aktivitetsfunktioner

Testa klientfunktioner

Testa klientåtgärder

Relaterat innehåll

Feedback

Ytterligare resurser