Test unitaire de Durable Functions et des SDK Durable Task

Les tests unitaires d’orchestrations durables vous aident à vérifier la logique métier et à détecter les erreurs au début. Les orchestrations coordonnent plusieurs activités et peuvent croître rapidement, de sorte que les tests protègent contre les régressions à mesure que votre flux de travail évolue.

Sélectionnez l’onglet correspondant à votre projet : Durable Functions si vous utilisez Azure Functions ou Durable Task SDK si vous utilisez le SDK autonome sans Azure Functions.

Avec Durable Functions, vous testez les fonctions d'orchestration, d'activités et de client (déclencheur) en simulant les objets de contexte fournis par le cadre et en appelant directement vos fonctions. Cette approche isole votre logique métier du runtime Azure Functions.

Voici un test d’orchestrateur C# minimal pour afficher le modèle :

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

Le reste de cet article décrit ce modèle en détail pour C# et Python.

Les kits SDK Durable Task autonomes fournissent une infrastructure de test intégrée qui exécute des orchestrations en mémoire sans dépendances externes. Vous inscrivez les orchestrateurs et les activités auprès d’un worker de test, planifiez des orchestrations via un client de test et validez les résultats. Aucune technique de mocking n’est requise pour C# et JavaScript. Python utilise une approche basée sur un générateur avec l’injection manuelle de résultats.

Voici un test C# minimal pour afficher le modèle :

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

Le reste de cet article décrit ce modèle en détail pour C#, Python et JavaScript.

Prerequisites

xUnit — framework de test
Moq — Framework de simulation
Connaissance du modèle worker isolé .NET

xUnit — framework de test
Package NuGet Microsoft.DurableTask.InProcessTestHost (v1.0.0 ou version ultérieure)

Tester les fonctions d’orchestrateur

Les fonctions Orchestrator coordonnent les activités, les minuteurs et les événements externes. Ils contiennent généralement la logique métier la plus grande et bénéficient le plus des tests unitaires.

Simulez le contexte d’orchestration afin de contrôler les valeurs de retour des appels d’activité. Appelez ensuite votre orchestrateur directement et vérifiez la sortie.

Considérez cet orchestrateur qui appelle une activité trois fois :

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

Utilisez Moq pour simuler TaskOrchestrationContext et configurer les valeurs de retour attendues pour chaque appel d’activité.

Note

Le It.Is<TaskName>(...) modèle est requis, car CallActivityAsync accepte un TaskName struct, et non une chaîne simple. Moq nécessite une correspondance explicite de types.

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

Considérez cet orchestrateur qui enchaîne trois appels d’activité :

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]

Fictivez le contexte et utilisez-le orchestrator_generator_wrapper pour traiter le générateur.

Note

Le SDK Azure Durable Functions fournit orchestrator_generator_wrapper pour simuler le mécanisme de relecture qui pilote les orchestrateurs Python. Le Kit de développement logiciel (SDK) Durable Task autonome n’inclut pas cet utilitaire. L’onglet Kits de développement logiciel (SDK) Tâche durable utilise plutôt des appels manuelsgen.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!"])

Utilisez DurableTaskTestHost pour exécuter des orchestrations en mémoire. Inscrivez vos classes d’orchestrateurs et d’activités de production, planifiez une orchestration, puis validez le résultat.

Compte tenu de ces classes de production :

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

Inscrivez-les directement dans l’hôte de test :

[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 exécute un moteur d’orchestration en mémoire complet. Aucun service externe ni processus sidecar n’est requis.

Le SDK Python pour les tâches durables ne propose pas encore une infrastructure de test intégrée comme c'est le cas pour C# et JavaScript. Utilisez le mocking standard pour tester la logique d'orchestrateur. Fictivez le générateur et pilotez-le OrchestrationContext en envoyant des résultats d’activité simulés pour chaque yield.

Note

Contrairement au SDK Azure Durable Functions (qui fournit orchestrator_generator_wrapper), le SDK Durable Task autonome vous oblige à faire avancer manuellement le générateur avec gen.send(). Cela vous permet de contrôler explicitement les résultats de l’activité simulée.

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

Cette approche teste le flux de contrôle de l’orchestrateur sans dépendre des détails internes du Kit de développement logiciel (SDK).

Utilisez TestOrchestrationWorker et TestOrchestrationClient pour exécuter les orchestrations en mémoire.

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

L’infrastructure de test exécute le moteur d’orchestration complet en mode in-process. Aucun side-car ou aucun service externe n’est requis.

Fonctions d’activité de test

Les fonctions d’activité contiennent le travail réel : appel d’API, traitement des données ou interaction avec des systèmes externes. Il s’agit du type de fonction le plus simple à tester, car il n’a pas de comportement de reprise spécifique au framework.

Les fonctions d’activité dans Azure Functions reçoivent une entrée et éventuellement une FunctionContext. Testez-les comme n’importe quelle autre fonction :

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

Les fonctions d’activité dans Azure Functions sont des fonctions Python régulières. Testez-les directement. Pour plus d’informations, consultez Azure Functions Python tests unitaires.

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

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

Les fonctions d’activité reçoivent un objet de contexte et une entrée. Le contexte fournit des métadonnées telles que l’ID d’orchestration et l’ID de tâche, mais la plupart des tests n’en ont pas besoin.

À l’aide de la SayHelloActivity classe de l’exemple d’orchestrateur, appelez RunAsync directement avec un contexte fictif :

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

Lorsque vous utilisez DurableTaskTestHost, les activités s’exécutent également dans le cadre du test d’orchestration. Vous n’avez pas besoin de tests d’activité distincts, sauf si l’activité a une logique complexe.

Testez directement la fonction d’activité : aucune configuration spéciale n’est requise :

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

Testez directement la fonction d’activité :

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

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

Tester les fonctions clientes

Les fonctions clientes (également appelées fonctions de déclencheur) démarrent des orchestrations et gèrent des instances. Ils utilisent la liaison du client durable pour interagir avec le moteur d’orchestration.

Tenez compte de ce déclencheur HTTP qui démarre une orchestration :

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

Simuler DurableTaskClient pour retourner un ID d’instance connu :

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

Tenez compte de ce déclencheur HTTP qui démarre une orchestration :

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

Fictivez le client durable :

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

Tester les opérations du client

Avec les SDK Durable Task autonomes, les opérations côté client (orchestrations d'ordonnancement, consultation de l'état, envoi d'événements) utilisent les mêmes TestOrchestrationClient déjà montrés dans les tests d’orchestrateur. Aucune fonction cliente distincte n’existe : vous appelez directement l’API cliente.

DurableTaskTestHost host.Client expose, qui est un DurableTaskClient entièrement fonctionnel. Utilisez-le pour tester les opérations du client, telles que la planification, la requête ou l'arrêt des orchestrations.

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

Le sdk Python Tâche durable ne fournit pas encore de client de test intégré. Testez la logique côté client (planification, interrogation) en moquant le 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 prend en charge les mêmes opérations que le client de production. Utilisez-le pour tester la planification, les requêtes d’état et le déclenchement d’événements :

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

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-28

Test unitaire de Durable Functions et des SDK Durable Task

Prerequisites

Tester les fonctions d’orchestrateur

Fonctions d’activité de test

Tester les fonctions clientes

Tester les opérations du client

Contenu connexe

Commentaires

Ressources supplémentaires