Birim testi

Birim testleri iş mantığını doğrular ve regresyonlara karşı koruma sağlar. Kalıcı düzenlemeler birden çok etkinliği koordine eder ve hızla karmaşıklaşabilir. Birim testleri eklemek hataları erken yakalamanıza yardımcı olur.

Durable Functions ile orkestratörleri, etkinlikleri ve istemci (tetikleyici) işlevlerini çerçeve tarafından sağlanan bağlam nesnelerini taklit ederek ve işlevlerinizi doğrudan çağırarak test edebilirsiniz. Bu yaklaşım, iş mantığınızı Azure Functions çalışma zamanından ayırır.

Tek başına Dayanıklı Görev SDK'ları, harici bağımlılıklar olmadan bellek içinde düzenleme çalıştıran yerleşik test altyapısı sağlar. Orkestratörleri ve aktiviteleri bir test çalışanına kaydeder, bir test istemcisi aracılığıyla orkestrasyonları zamanlar ve sonuçları doğrularsınız. C# ve JavaScript için mock kütüphaneleri gerekmez. Python sahte geçmiş olaylarıyla yürütücü tabanlı bir yaklaşım kullanır.

Önkoşullar

C#

• xUnit — test çerçevesi
• Moq — sahte çerçeve
• .NET yalıtılmış çalışan modeli hakkında bilgi

Python

• Python unittest — test çerçevesi
• unittest.mock — sahte kitaplık
• "Python v2 programlama modeli hakkında bilgi sahibi olmak"

JavaScript

Durable Functions için JavaScript birim testi bu makalede ele alınmıyor.

C#

• xUnit — test çerçevesi
• Microsoft.DurableTask.InProcessTestHost NuGet paketi

Python

• pytest — test çerçevesi (veya unittest)
• durabletask PyPI paketi

JavaScript

• Jest — test çerçevesi
• @microsoft/durabletask-js npm paketi

Düzenleyici işlevlerini test edin

Orchestrator işlevleri etkinlikleri, zamanlayıcıları ve dış olayları koordine eder. Bunlar genellikle en çok iş mantığını içerir ve birim testinden en iyi şekilde yararlanırlar.

Etkinlik çağrılarının dönüş değerlerini denetlemek için orkestrasyon bağlamını simüle edin. Ardından orchestrator'ınızı doğrudan çağırın ve çıkışı doğrulayın.

C#

Bir etkinliği üç kez çağıran bu düzenleyiciyi göz önünde bulundurun:

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

Her etkinlik çağrısı için beklenen dönüş değerlerini taklit TaskOrchestrationContext etmek ve ayarlamak için Moq kullanın:

[Fact]
public async Task HelloCities_ReturnsExpectedGreetings()
{
    var contextMock = new Mock<TaskOrchestrationContext>();

    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

Üç etkinlik çağrısını ardışık olarak zincirleyen bu orkestratörü göz önünde bulundurun.

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]

Bağlamı taklit edin ve orchestrator_generator_wrapper kullanarak oluşturucuyu işleyin. Bu yardımcı program, Durable Functions yeniden yürütme mekanizmasının simülasyonunu gerçekleştirir.

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

Durable Functions için JavaScript birim testi bu makalede ele alınmıyor.

C#

Bellek içinde orkestrasyonları çalıştırmak için DurableTaskTestHost kullanın. Üretim orkestratörünüzü ve etkinlik sınıflarınızı kaydedin, bir orkestrasyon zamanlayın ve sonucu doğrulayın.

Bu üretim sınıflarını göz önünde bulundurarak:

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

Bunları doğrudan test konağına kaydedin:

[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 tam bir bellek içi orkestrasyon motoru çalıştırır. Dış hizmetler veya yan araç süreçleri gerekmez.

Python

Python Dayanıklı Görev SDK'sı henüz C# ve JavaScript gibi yerleşik bir test altyapısı sağlamaz. "Orkestratör mantığını test etmek için standart mock kullanın." OrchestrationContext öğesini taklit edin ve jeneratörü her bir yield için sanal etkinlik sonuçlarını geri göndererek çalıştırın.

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

Bu yaklaşım, SDK iç bileşenlerine bağlı olmadan düzenleyicinin denetim akışını test eder.

JavaScript

Bellek içinde orkestrasyonları çalıştırmak için TestOrchestrationWorker ve TestOrchestrationClient kullanın.

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

Test altyapısı, işlem sırasında tam orkestrasyon motorunu çalıştırır. Sidecar veya harici hizmetler gerekmez.

Test etkinliği işlevleri

Etkinlik işlevleri, API'leri çağırma, verileri işleme veya dış sistemlerle etkileşim kurma gibi gerçek çalışmayı içerir. Çerçeveye özgü yeniden yürütme davranışı olmadığından test etmek için en basit işlev türüdür.

C#

Azure Functions'daki etkinlik işlevleri bir giriş alır ve isteğe bağlı bir FunctionContext içerir. Bunları diğer işlevler gibi test edin:

[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

Azure Functions etkinlik işlevleri normal Python işlevleridir. Bunları doğrudan test edin. Daha fazla bilgi için bkz. Azure Functions Python birim testi.

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

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

JavaScript

Durable Functions için JavaScript birim testi bu makalede ele alınmıyor.

Etkinlik işlevleri bir bağlam nesnesi ve giriş alır. Bağlam düzenleme kimliği ve görev kimliği gibi meta veriler sağlar, ancak çoğu test buna ihtiyaç duymaz.

C#

Orchestrator örneğindeki SayHelloActivity sınıfını kullanarak, RunAsync'i sahte bir bağlam ile doğrudan çağırın.

[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 kullandığınızda, etkinlikler orkestrasyon testinin bir parçası olarak da çalıştırılır. Etkinliğin karmaşık mantığı olmadığı sürece ayrı etkinlik testlerine ihtiyacınız yoktur.

Python

Etkinlik işlevini doğrudan test edin; özel kurulum gerekmez:

from durabletask import task


def hello(ctx: task.ActivityContext, name: str) -> str:
    return f"Hello {name}!"


def test_hello():
    result = hello(None, "Tokyo")
    assert result == "Hello Tokyo!"

JavaScript

Etkinlik işlevini doğrudan test edin:

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

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

İstemci işlevlerini test et

İstemci işlevleri (tetikleyici işlevleri olarak da adlandırılır) orkestrasyonları başlatır ve örnekleri yönetir. Orkestrasyon motoruyla etkileşime geçmek için dayanıklı istemci bağlantısını kullanırlar.

C#

Bir orkestrasyonu başlatan bu HTTP tetikleyicisini göz önünde bulundurun:

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

Bilinir bir örnek kimliği döndürmesi için DurableTaskClient nesnesini taklit et:

[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

Bir orkestrasyonu başlatan bu HTTP tetikleyicisini göz önünde bulundurun:

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

Dayanıklı istemciyle alay edin:

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

Durable Functions için JavaScript birim testi bu makalede ele alınmıyor.

İlgili içerik

• Dayanıklı İşlevlere genel bakış
• Orchestrator işlev kodu kısıtlamaları

• Dayanıklı Görev nedir?
• Orchestrator işlev kodu kısıtlamaları