Durable Functions および Durable Task SDK の単体テストを行う

単体テストの持続的オーケストレーションは、ビジネスロジックを検証し、早期にエラーをキャッチするのに役立ちます。オーケストレーションは複数のアクティビティを調整し、複雑になる可能性があるため、ワークフローの進化に合わせてテストが回帰から保護されます。

Azure Functionsを使用する場合は Durable Functions、Azure Functionsなしでスタンドアロン SDK を使用する場合は < >c1>Durable Task SDK プロジェクトに一致するタブを選択します。

Durable Functionsでは、オーケストレーター、アクティビティ、およびクライアント (トリガー) 関数をテストするには、フレームワークによって提供されるコンテキストオブジェクトを直接呼び出します。この方法では、ビジネスロジックが Azure Functions ランタイムから分離されます。

パターンを示す最小限の C# オーケストレーターテストを次に示します。

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

この記事の残りの部分では、C# とPythonのこのパターンについて詳しく説明します。

スタンドアロンの Durable Task SDK は、外部の依存関係なしでメモリ内でオーケストレーションを実行する 組み込みのテストインフラストラクチャ を提供します。オーケストレーターとアクティビティをテストワーカーに登録し、テストクライアントを使用してオーケストレーションをスケジュールし、結果をアサートします。 C# と JavaScript にモックは必要ありません。 Pythonでは、手動の結果挿入でジェネレーターベースのアプローチを使用します。

パターンを示す最小限の C# テストを次に示します。

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

この記事の残りの部分では、C#、Python、JavaScript のこのパターンについて詳しく説明します。

前提条件

xUnit — テストフレームワーク
Moq — モックフレームワーク
.NET分離ワーカーモデルに関する知識

xUnit — テストフレームワーク
Microsoft.DurableTask.InProcessTestHost NuGet パッケージ (v1.0.0 以降)

オーケストレーター関数をテストする

オーケストレーター関数は、アクティビティ、タイマー、および外部イベントを調整します。通常は、最も多くのビジネスロジックが含まれており、単体テストのメリットが最も高まります。

オーケストレーションコンテキストをモックして、アクティビティ呼び出しの戻り値を制御します。次に、オーケストレーターを直接呼び出し、出力を確認します。

アクティビティを 3 回呼び出すこのオーケストレーターについて考えてみましょう。

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

Moq を使用して TaskOrchestrationContext をモックし、各アクティビティ呼び出しに対して期待される戻り値を設定します。

Note

It.Is<TaskName>(...)はプレーン文字列ではなくCallActivityAsync構造体を受け入れるため、TaskName パターンが必要です。 Moq には、明示された型の一致が必要です。

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

次の 3 つのアクティビティ呼び出しをチェーンするオーケストレーターについて考えてみましょう。

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]

コンテキストをモックし、 orchestrator_generator_wrapper を使用してジェネレーターを処理します。

Note

Azure Durable Functions SDKは、Pythonオーケストレータージェネレーターを駆動する再生メカニズムをシミュレートするためのorchestrator_generator_wrapperを提供しています。スタンドアロンの Durable Task SDK にはこのユーティリティが含まれていないため、[ Durable Task SDK ] タブでは代わりに手動 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!"])

DurableTaskTestHostを使用して、メモリ内でオーケストレーションを実行します。運用オーケストレーターとアクティビティクラスを登録し、オーケストレーションをスケジュールし、その結果を確認します。

次の実稼働クラスが与えられている場合:

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

テストホストに直接登録します。

[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 は、完全なメモリ内オーケストレーションエンジンを実行します。外部サービスやサイドカープロセスは必要ありません。

Python Durable Task SDK には、C# や JavaScript などの組み込みのテストハーネスはまだ用意されていません。オーケストレーターロジックをテストする際は、標準的なモックを使用します。 OrchestrationContextをモックし、シミュレートされたアクティビティの結果を各yieldに送信してジェネレーターを駆動します。

Note

Azure Durable Functions SDK (orchestrator_generator_wrapper を提供) とは異なり、スタンドアロン Durable Task SDK では、gen.send() を使用してジェネレーターを手動で進める必要があります。これにより、シミュレートされたアクティビティの結果を明示的に制御できます。

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

この方法では、SDK の内部に依存することなく、オーケストレーターの制御フローをテストします。

TestOrchestrationWorkerとTestOrchestrationClientを使用して、メモリ内でオーケストレーションを実行します。

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

テストインフラストラクチャは、完全なオーケストレーションエンジンをインプロセスで実行します。サイドカーや外部サービスは必要ありません。

アクティビティ関数をテストする

アクティビティ関数には、API の呼び出し、データの処理、外部システムとの対話など、実際の作業が含まれます。フレームワーク固有の再生動作がないため、テストする最も簡単な関数型です。

Azure Functionsのアクティビティ関数は、入力と必要に応じて FunctionContext を受け取ります。他の関数と同様にテストします。

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

Azure Functionsのアクティビティ関数は、通常のPython関数です。直接テストします。詳細については、「Azure Functions Python単体テストを参照してください。

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

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

アクティビティ関数は、コンテキストオブジェクトと入力を受け取ります。コンテキストはオーケストレーション ID やタスク ID などのメタデータを提供しますが、ほとんどのテストでは必要ありません。

オーケストレーターの例の SayHelloActivity クラスを使用して、モックコンテキストを使用して RunAsync を直接呼び出します。

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

DurableTaskTestHostを使用すると、アクティビティもオーケストレーションテストの一部として実行されます。アクティビティに複雑なロジックがない限り、個別のアクティビティテストは必要ありません。

アクティビティ関数を直接テストします。特別な設定は必要ありません。

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

アクティビティ関数を直接テストします。

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

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

クライアント関数をテストする

クライアント関数 (トリガー関数とも呼ばれます) はオーケストレーションを開始し、インスタンスを管理します。永続的なクライアントバインドを使用してオーケストレーションエンジンと対話します。

オーケストレーションを開始する次の HTTP トリガーについて考えてみましょう。

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

モック DurableTaskClient を使用して既知のインスタンス 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);
}

オーケストレーションを開始する次の HTTP トリガーについて考えてみましょう。

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

永続的なクライアントをモックします:

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

クライアント操作をテストする

スタンドアロンの Durable Task SDK では、クライアント操作 (オーケストレーションのスケジュール設定、状態の照会、イベントの発生) では、オーケストレーターテストに既に示されているのと同じ TestOrchestrationClient が使用されます。別のクライアント関数は存在しません。クライアント API を直接呼び出します。

DurableTaskTestHostは、完全に機能するhost.ClientであるDurableTaskClientを公開します。これを使用して、オーケストレーションのスケジュール、クエリ、終了などのクライアントレベルの操作をテストします。

[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 には、組み込みのテストクライアントがまだ用意されていません。 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 では、運用クライアントと同じ操作がサポートされます。これを使用して、スケジュール、状態クエリ、イベント発生をテストします。

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

フィードバック

このページはお役に立ちましたか?

Last updated on 2026-04-28

Durable Functions および Durable Task SDK の単体テストを行う

前提条件

オーケストレーター関数をテストする

アクティビティ関数をテストする

クライアント関数をテストする

クライアント操作をテストする

関連するコンテンツ

フィードバック

その他のリソース