Testowanie jednostkowe funkcji Durable i zestawów SDK zadań Durable

Testy jednostkowe trwałych orkiestracji pomagają zweryfikować logikę biznesową i wcześnie wykrywać błędy. Orkiestracje koordynują wiele działań i mogą się szybko skomplikować, więc testy chronią przed regresjami w miarę rozwoju workflow.

Wybierz kartę zgodną z projektem: Durable Functions jeśli używasz Azure Functions lub Durable Task SDK jeśli używasz autonomicznego zestawu SDK bez Azure Functions.

Za pomocą Durable Functions można testować funkcje orkiestratorów, działań i klienta (wyzwalacza) przez mocowanie obiektów kontekstowych dostarczanych przez platformę i wywoływanie funkcji bezpośrednio. Takie podejście izoluje logikę biznesową od środowiska uruchomieniowego Azure Functions.

Oto minimalny test orkiestratora języka C#, aby pokazać wzorzec:

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

W pozostałej części tego artykułu szczegółowo omówiono ten wzorzec dla języka C# i Python.

Samodzielne zestawy SDK rozszerzenia Durable Task zapewniają wbudowaną infrastrukturę testową, która uruchamia orkiestracje w pamięci operacyjnej bez zależności zewnętrznych. Rejestrujesz orkiestratorów i działania przy użyciu procesu roboczego testowego, planujesz aranżacje za pośrednictwem klienta testowego i potwierdzasz wyniki. Nie jest wymagane wyśmiewanie w językach C# i JavaScript. Python używa podejścia opartego na generatorze z ręcznym wstrzykiwaniem wyników.

Oto minimalny test języka C#, aby pokazać wzorzec:

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

W pozostałej części tego artykułu szczegółowo opisano ten wzorzec dla języków C#, Python i JavaScript.

Wymagania wstępne

C#

• xUnit — struktura testowa
• Moq — framework do tworzenia obiektów zastępczych
• Znajomość modelu .NET izolowanego procesu roboczego

Python

• Python unittest — struktura testowa
• unittest.mock — biblioteka do mockowania
• Znajomość modelu programowania Python v2

JavaScript

Testowanie jednostkowe języka JavaScript dla Durable Functions wymaga autonomicznego zestawu Durable Task SDK. Przejdź na kartę Durable Task SDKs w górnej części tej strony, aby zobaczyć przykłady testowania w JavaScript z wbudowaną infrastrukturą testową.

C#

• xUnit — struktura testowa
• Pakiet NuGet Microsoft.DurableTask.InProcessTestHost (wersja 1.0.0 lub nowsza)

Python

• pytest — struktura testowa (lub unittest)
• durabletask Pakiet PyPI

JavaScript

• Jest — struktura testowa
• Pakiet @microsoft/durabletask-js npm

Funkcje orkiestratora testów

Funkcje programu Orchestrator koordynują działania, czasomierze i zdarzenia zewnętrzne. Zwykle zawierają one najbardziej logikę biznesową i korzystają najbardziej z testów jednostkowych.

Zasymuluj kontekst orkiestracji, aby kontrolować zwracane wartości wywołań aktywności. Następnie bezpośrednio wywołaj orchestratora i zweryfikuj dane wyjściowe.

C#

Rozważ ten orkiestrator, który wywołuje aktywność trzy razy:

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

Użyj Moq do mockowania TaskOrchestrationContext i skonfiguruj oczekiwane wartości zwracane dla każdego wywołania aktywności.

Note

Wzorzec It.Is<TaskName>(...) jest wymagany, ponieważ CallActivityAsync akceptuje TaskName strukturę, a nie zwykły ciąg. Moq wymaga jawnej zgodności typu.

[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

Rozważmy ten orkiestrator, który zawiera trzy wywołania działań:

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]

Symuluj kontekst i użyj orchestrator_generator_wrapper do przetworzenia generatora.

Note

Zestaw SDK Azure Durable Functions udostępnia orchestrator_generator_wrapper do symulowania mechanizmu odtwarzania, który steruje generatorami orkiestratora w Pythonie. Autonomiczne zestawy SDK Durable Task nie zawierają tego narzędzia, więc zakładka Zestawy SDK Durable Task używa zamiast tego wywołań ręcznych gen.send().

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

W przypadku testowania jednostkowego języka JavaScript przejdź do karty Durable Task SDKs na górze strony.

C#

Służy DurableTaskTestHost do uruchamiania aranżacji w pamięci. Zarejestruj orkiestratora produkcyjnego i klasy działań, zaplanuj orkiestrację i zweryfikuj wynik.

Biorąc pod uwagę te klasy produkcyjne:

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

Zarejestruj je bezpośrednio na hoście testowym:

[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 uruchamia kompletny silnik orkiestracji w pamięci. Nie są wymagane żadne usługi zewnętrzne ani procesy pomocnicze.

Python

Zestaw PYTHON Durable Task SDK nie udostępnia jeszcze wbudowanej uprzęży testowej, takiej jak C# i JavaScript. Użyj standardowego mockowania do testowania logiki orkiestratora. Wyzwól generator OrchestrationContext i wysyłaj symulowane wyniki działania z powrotem dla każdego yield.

Note

W przeciwieństwie do pakietu SDK Azure Durable Functions (który zapewnia orchestrator_generator_wrapper), autonomiczny pakiet Durable Task SDK wymaga ręcznego przesuwania generatora przy użyciu gen.send(). Daje to pełną kontrolę nad wynikami symulowanych działań.

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

Takie podejście sprawdza przepływ sterowania koordynatora bez polegania na wewnętrznych mechanizmach SDK.

JavaScript

Użyj funkcji TestOrchestrationWorker i TestOrchestrationClient , aby uruchomić aranżacje w pamięci:

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

Infrastruktura testowa uruchamia pełny silnik orkiestracji wewnątrz procesu. Nie są wymagane żadne usługi przyczepki ani usługi zewnętrzne.

Funkcje działania testowego

Funkcje działania zawierają rzeczywistą pracę — wywoływanie interfejsów API, przetwarzanie danych lub interakcja z systemami zewnętrznymi. Są najprostszym typem funkcji do przetestowania, ponieważ nie mają zachowania odtwarzania specyficznego dla struktury.

C#

Funkcje działania w Azure Functions odbierają dane wejściowe i opcjonalnie FunctionContext. Przetestuj je tak jak każda inna funkcja:

[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

Funkcje działania w Azure Functions to zwykłe funkcje Python. Przetestuj je bezpośrednio. Aby uzyskać więcej informacji, zobacz Azure Functions Python testy jednostkowe.

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

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

JavaScript

W przypadku testowania działań w języku JavaScript przejdź do zakładki Durable Task SDKs u góry tej strony.

Funkcje działania odbierają obiekt kontekstu i dane wejściowe. Kontekst zawiera metadane, takie jak identyfikator orkiestracji i identyfikator zadania, ale większość testów tego nie wymaga.

C#

Korzystając z klasy SayHelloActivity z przykładu orkiestratora, wywołaj RunAsync bezpośrednio z pozorowanym kontekstem.

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

W przypadku korzystania z DurableTaskTestHost, działania są również uruchamiane w ramach testu orkiestracji. Nie potrzebujesz oddzielnych testów aktywności, chyba że działanie ma złożoną logikę.

Python

Przetestuj funkcję działania bezpośrednio — nie jest wymagana żadna specjalna konfiguracja:

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

Przetestuj funkcję działania bezpośrednio:

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

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

Testowanie funkcji klienta

Funkcje klienta (nazywane również funkcjami wyzwalającymi) uruchamiają orkiestracje i zarządzają instancjami. Używają trwałego powiązania klienta w celu interakcji z silnikiem orkiestracji.

C#

Rozważmy ten wyzwalacz HTTP, który uruchamia aranżację:

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

Pozorowanie DurableTaskClient zwracania znanego identyfikatora wystąpienia:

[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

Rozważmy ten wyzwalacz HTTP, który uruchamia aranżację:

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

Pozorowanie trwałego klienta:

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

W przypadku testowania klienta języka JavaScript przejdź do karty Durable Task SDK na górze tej strony.

Testowanie operacji klienta

W przypadku autonomicznych zestawów SDK trwałych zadań operacje klienta (planowanie orkiestracji, zapytania o stan, podnoszenie zdarzeń) używają tego samego TestOrchestrationClient, co pokazano już w testach orkiestratora. Nie istnieje żadna oddzielna funkcja klienta — bezpośrednio wywołujesz interfejs API klienta.

C#

DurableTaskTestHost ujawnia host.Client, który jest w pełni funkcjonalnym DurableTaskClient. Służy do testowania operacji na poziomie klienta, takich jak planowanie, wykonywanie zapytań lub kończenie aranżacji:

[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

Zestaw PYTHON Durable Task SDK nie udostępnia jeszcze wbudowanego klienta testowego. Przetestuj logikę na poziomie klienta (planowanie, wykonywanie zapytań) przez wyśmiewanie elementu 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")

JavaScript

TestOrchestrationClient obsługuje te same operacje co klient produkcyjny. Służy do testowania planowania, zapytań dotyczących statusu i generowania zdarzeń.

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

Treści powiązane

• Omówienie rozszerzenia Durable Functions
• Ograniczenia kodu funkcji programu Orchestrator
• Przenieś z wbudowanego procesu do izolowanego pracownika (.NET)
• Serializacja i trwałość w Durable Functions

• Co to jest trwałe zadanie?
• Ograniczenia kodu funkcji programu Orchestrator
• Programowanie za pomocą narzędzia Durable Task Scheduler