اختبار الوحدة

اختبارات الوحدة تتحقق من منطق الأعمال وتحمي من الانحدارات. تنسق التوزيعات الموسيقية المتطورة أنشطة متعددة ويمكن أن تصبح معقدة بسرعة. إضافة اختبارات الوحدات تساعدك على اكتشاف الأخطاء مبكرا.

مع Durable Functions، تختبر المنسقين والأنشطة ودوال العميل (المحفز) عن طريق محاكاة كائنات السياق المقدمة من الإطار واستدعاء وظائفك مباشرة. هذا النهج يعزل منطق عملك عن وقت تشغيل Azure Functions.

توفر مجموعات تطوير المهام المستدامة المستقلة بنية تحتية اختبار مدمجة تشغل التنسيقات في الذاكرة دون تبعيات خارجية. تقوم بتسجيل المنسقين والأنشطة مع عامل اختبار، وتحدد جدولة التنسيقات من خلال عميل الاختبار، وتؤكد على النتائج. لا حاجة للمحاكاة في C# وJavaScript. تستخدم Python نهجا قائما على المنفذ مع أحداث تاريخ تجريبي.

المتطلبات الأساسية

C#‎

• xUnit — إطار عمل اختبار
• Moq — إطار عمل ساخر
• هل هو مألوف بنموذج العامل المعزول .NET

Python

• Python unittest — إطار اختبار
• unittest.mock — مكتبة السخرية
• هل هي مألفة بنموذج البرمجة Python v2

JavaScript

اختبار وحدات جافاسكريبت ل Durable Functions غير مغطى في هذا المقال.

C#‎

• xUnit — إطار عمل اختبار
• Microsoft.DurableTask.InProcessTestHost حزمة NuGet

Python

• 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 وإعداد قيم العائد المتوقعة لكل استدعاء نشاط:

[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

فكر في هذا المنسق الذي يربط ثلاث استدعاءات نشاط:

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 لمعالجة المولد. تحاكي هذه الأداة آلية إعادة التشغيل في Durable Functions:

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 غير مغطى في هذا المقال.

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

حزمة تطوير المهام الدائمة Python لا توفر بعد حزمة اختبار مدمجة مثل C# وJavaScript. استخدم المحاكاة القياسية لاختبار منطق الأوركستراتور. قم بمحاكاة و OrchestrationContext تشغيل المولد عن طريق إرسال نتائج نشاط محاكاة لكل yield:

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

تعمل بنية الاختبار على تشغيل محرك التوزيع الموسيقي الكامل أثناء العملية. لا حاجة لخدمات جانبية أو خارجية.

دوال نشاط الاختبار

تحتوي دوال النشاط على العمل الفعلي — استدعاء واجهات برمجة التطبيقات (APIs)، معالجة البيانات، أو التفاعل مع الأنظمة الخارجية. هي أبسط نوع من الدوال للاختبار لأنها لا تملك سلوك إعادة تشغيل خاص بإطار العمل.

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

Python

دوال النشاط في 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

اختبار وحدات جافاسكريبت ل Durable Functions غير مغطى في هذا المقال.

تستقبل دوال النشاط كائن سياق ومدخل. يوفر السياق بيانات وصفية مثل معرف التوزيع ومعرف المهمة، لكن معظم الاختبارات لا تحتاجها.

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، تشغل الأنشطة أيضا كجزء من اختبار التوزيع الموسيقي. لا تحتاج إلى اختبارات نشاط منفصلة إلا إذا كان النشاط منطقيا معقدا.

Python

اختبر دالة النشاط مباشرة — لا يتطلب الأمر إعدادا خاصا:

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

اختبر دالة النشاط مباشرة:

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

محاكاة 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);
}

Python

فكر في هذا المشغل 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):
        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 غير مغطى في هذا المقال.

المحتوى ذو الصلة

• نظرة عامة Durable Functions
• قيود كود وظائف التنسيق

• ما هي المهمة المتطورة؟
• قيود كود وظائف التنسيق