Durable Functions 및 Durable Task SDK 단위 테스트입니다.

지속성 오케스트레이션을 단위 테스트하면 비즈니스 논리를 확인하고 오류를 조기에 발견할 수 있습니다. 오케스트레이션은 여러 활동을 조정하고 빠르게 복잡해질 수 있으므로 워크플로가 발전함에 따라 테스트가 회귀로부터 보호됩니다.

프로젝트와 일치하는 탭을 선택합니다. Azure Functions 사용하는 경우 Durable Functions 또는 Azure Functions 없이 독립 실행형 SDK를 사용하는 경우 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 대한 이 패턴이 자세히 설명되어 있습니다.

독립 실행형 지속성 작업 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에 대한 이 패턴이 자세히 설명되어 있습니다.

사전 요구 사항

C#

• xUnit — 테스트 프레임워크
• Moq - 모의 프레임워크
• .NET 격리된 작업자 모델

파이썬

• Python unittest — 테스트 프레임워크
• unittest.mock - 모의 라이브러리
• Python v2 프로그래밍 모델

JavaScript

Durable Functions JavaScript 단위 테스트에는 독립 실행형 지속성 작업 SDK가 필요합니다. 기본 제공 테스트 인프라를 사용하는 JavaScript 테스트 예제를 보려면 이 페이지 맨 위에 있는 지속성 작업 SDK 탭으로 전환합니다.

C#

• xUnit — 테스트 프레임워크
• Microsoft.DurableTask.InProcessTestHost NuGet 패키지(v1.0.0 이상)

파이썬

• pytest — 테스트 프레임워크(또는 unittest)
• durabletask PyPI 패키지

JavaScript

• Jest — 테스트 프레임워크
• @microsoft/durabletask-js npm 패키지

오케스트레이터 함수 테스트

오케스트레이터 함수는 활동, 타이머 및 외부 이벤트를 조정합니다. 일반적으로 가장 많은 비즈니스 논리를 포함하며 단위 테스트를 통해 가장 많은 이점을 얻을 수 있습니다.

오케스트레이션 컨텍스트를 모의하여 활동 호출의 반환 값을 제어합니다. 그런 다음, 오케스트레이터를 직접 호출하고 출력을 확인합니다.

C#

작업을 세 번 호출하는 이 오케스트레이터를 고려합니다.

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

파이썬

세 가지 작업 호출을 체인하는 이 오케스트레이터를 고려합니다.

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는 orchestrator_generator_wrapper 제공하여 Python 오케스트레이터 생성기를 구동하는 재생 메커니즘을 시뮬레이션합니다. 독립 실행형 지속성 작업 SDK는 이 유틸리티를 포함하지 않으므로 지속성 작업 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!"])

JavaScript

JavaScript 단위 테스트의 경우 이 페이지 맨 위에 있는 지속성 작업 SDK 탭으로 전환합니다.

C#

메모리 내 오케스트레이션을 실행하는 데 사용합니다 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 지속성 작업 SDK는 아직 C# 및 JavaScript와 같은 기본 제공 테스트 도구가 제공되지 않습니다. 표준 모의 작업을 사용하여 오케스트레이터 논리를 테스트합니다. 각각OrchestrationContext에 yield 대해 시뮬레이션된 활동 결과를 다시 전송하여 생성기를 모의 및 구동합니다.

Note

orchestrator_generator_wrapper 제공하는 Azure Durable Functions SDK와 달리 독립 실행형 지속성 작업 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 내부 요소에 의존하지 않고 오케스트레이터의 제어 흐름을 테스트합니다.

JavaScript

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 호출, 데이터 처리 또는 외부 시스템과의 상호 작용과 같은 실제 작업이 포함됩니다. 프레임워크별 재생 동작이 없으므로 테스트할 수 있는 가장 간단한 함수 형식입니다.

C#

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

JavaScript

JavaScript 활동 테스트의 경우 이 페이지 맨 위에 있는 지속성 작업 SDK 탭으로 전환합니다.

활동 함수는 컨텍스트 개체와 입력을 받습니다. 컨텍스트는 오케스트레이션 ID 및 작업 ID와 같은 메타데이터를 제공하지만 대부분의 테스트는 필요하지 않습니다.

C#

오케스트레이터 예제의 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!"

JavaScript

작업 함수를 직접 테스트합니다.

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

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

클라이언트 함수 테스트

클라이언트 함수(트리거 함수라고도 함)는 오케스트레이션을 시작하고 인스턴스를 관리합니다. 지속성 클라이언트 바인딩을 사용하여 오케스트레이션 엔진과 상호 작용합니다.

C#

오케스트레이션을 시작하는 다음 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);
}

알려진 인스턴스 ID를 반환하는 모의 DurableTaskClient 설정.

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

JavaScript

JavaScript 클라이언트 테스트의 경우 이 페이지 맨 위에 있는 지속성 작업 SDK 탭으로 전환합니다.

클라이언트 작업 테스트

독립 실행형 지속성 작업 SDK를 사용하면 클라이언트 작업(오케스트레이션 예약, 상태 쿼리, 이벤트 발생)이 오케스트레이터 테스트에 이미 표시된 것과 동일하게 TestOrchestrationClient 사용됩니다. 별도의 클라이언트 함수가 없습니다. 클라이언트 API를 직접 호출합니다.

C#

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 지속성 작업 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")

JavaScript

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

관련 콘텐츠

• Durable Functions 개요
• 오케스트레이터 함수 코드 제약 조건
• &l;t;c0>인프로세스에서 격리된 워커(.NET)로 마이그레이션</c0>
• Durable Functions에서의 직렬화 및 지속성

• 지속성 작업란?
• 오케스트레이터 함수 코드 제약 조건
• 지속성 작업 스케줄러를 사용하여 개발