Comment procéder à un test unitaire de robots

L'exemple Tests CoreBot utilisé dans cette rubrique fait référence au package Microsoft.Bot.Builder.Testing, XUnit et Moq pour créer des tests unitaires.

L’exemple Tests CoreBot utilisé dans cette rubrique fait référence au package botbuilder-testing, Mochapour créer des tests unitaires et Mocha Test Explorer pour visualiser des résultats de test dans VS Code.

var sut = new BookingDialog();
var testClient = new DialogTestClient(Channels.Msteams, sut);

var reply = await testClient.SendActivityAsync<IMessageActivity>("hi");
Assert.Equal("Where would you like to travel to?", reply.Text);

reply = await testClient.SendActivityAsync<IMessageActivity>("Seattle");
Assert.Equal("Where are you traveling from?", reply.Text);

reply = await testClient.SendActivityAsync<IMessageActivity>("New York");
Assert.Equal("When would you like to travel?", reply.Text);

reply = await testClient.SendActivityAsync<IMessageActivity>("tomorrow");
Assert.Equal("OK, I will book a flight from Seattle to New York for tomorrow, Is this Correct?", reply.Text);

reply = await testClient.SendActivityAsync<IMessageActivity>("yes");
Assert.Equal("Sure thing, wait while I finalize your reservation...", reply.Text);

reply = testClient.GetNextReply<IMessageActivity>();
Assert.Equal("All set, I have booked your flight to Seattle for tomorrow", reply.Text);

La classe DialogTestClient est définie dans l'espace de noms Microsoft.Bot.Builder.Testing et incluse dans le package NuGet Microsoft.Bot.Builder.Testing.

const sut = new BookingDialog();
const testClient = new DialogTestClient('msteams', sut);

let reply = await testClient.sendActivity('hi');
assert.strictEqual(reply.text, 'Where would you like to travel to?');

reply = await testClient.sendActivity('Seattle');
assert.strictEqual(reply.text, 'Where are you traveling from?');

reply = await testClient.sendActivity('New York');
assert.strictEqual(reply.text, 'When would you like to travel?');

reply = await testClient.sendActivity('tomorrow');
assert.strictEqual(reply.text, 'OK, I will book a flight from Seattle to New York for tomorrow, Is this Correct?');

reply = await testClient.sendActivity('yes');
assert.strictEqual(reply.text, 'Sure thing, wait while I finalize your reservation...');

reply = testClient.getNextReply();
assert.strictEqual(reply.text, 'All set, I have booked your flight to Seattle for tomorrow');

La classe DialogTestClient est incluse dans le package npm botbuilder-testing.

La méthode SendActivityAsync<IActivity> vous permet d’envoyer un énoncé de SMS ou une IActivity à votre boîte de dialogue et retourne le premier message qu’il reçoit. Le paramètre <T> est utilisé pour retourner une instance fortement typée de la réponse afin que vous puissiez la déclarer sans avoir à la caster.

var reply = await testClient.SendActivityAsync<IMessageActivity>("hi");
Assert.Equal("Where would you like to travel to?", reply.Text);

Dans certains scénarios, votre robot peut envoyer plusieurs messages en réponse à une seule activité. Dans ces cas, DialogTestClient met en file d’attente les réponses et vous pouvez utiliser la méthode GetNextReply<IActivity> pour dépiler le message suivant de la file de réponse.

reply = testClient.GetNextReply<IMessageActivity>();
Assert.Equal("All set, I have booked your flight to Seattle for tomorrow", reply.Text);

GetNextReply<IActivity> retourne la valeur null s’il n’y a plus de messages dans la file de réponse.

La méthode sendActivity vous permet d’envoyer un énoncé de SMS ou une Activity à votre boîte de dialogue et retourne le premier message qu’il reçoit.

let reply = await testClient.sendActivity('hi');
assert.strictEqual(reply.text, 'Where would you like to travel to?');

Dans certains scénarios, votre robot peut envoyer plusieurs messages en réponse à une seule activité. Dans ces cas, DialogTestClient met en file d’attente les réponses et vous pouvez utiliser la méthode getNextReply pour dépiler le message suivant de la file de réponse.

reply = testClient.getNextReply();
assert.strictEqual(reply.text, 'All set, I have booked your flight to Seattle for tomorrow');

getNextReply retourne la valeur null s’il n’y a plus de messages dans la file de réponse.

Le code de l’exemple CoreBot déclare uniquement la propriété Text des activités retournées. Dans les bots plus complexes, vous souhaiterez peut-être déclarer d'autres propriétés telles que Speak, InputHint, ChannelData, etc.

Assert.Equal("Sure thing, wait while I finalize your reservation...", reply.Text);
Assert.Equal("One moment please...", reply.Speak);
Assert.Equal(InputHints.IgnoringInput, reply.InputHint);

Pour ce faire, vous pouvez vérifier chaque propriété individuellement comme indiqué ci-dessus, vous pouvez écrire vos propres utilitaires d’assistance pour déclarer des activités ou vous pouvez utiliser d'autres infrastructures comme FluentAssertions pour écrire des assertions personnalisées et simplifier votre code de test.

Le code de l’exemple CoreBot déclare uniquement la propriété text des activités retournées. Dans les bots plus complexes, vous souhaiterez peut-être déclarer d'autres propriétés telles que speak, inputHint, channelData, etc.

assert.strictEqual(reply.text, 'Sure thing, wait while I finalize your reservation...');
assert.strictEqual(reply.speak, 'One moment please...');
assert.strictEqual(reply.inputHint, InputHints.IgnoringInput);

Pour ce faire, vous pouvez vérifier chaque propriété individuellement comme indiqué ci-dessus, vous pouvez écrire vos propres utilitaires d’assistance pour déclarer des activités ou vous pouvez utiliser d'autres bibliothèques comme Chai pour écrire des assertions personnalisées et simplifier votre code de test.

var inputDialogParams = new BookingDetails()
{
    Destination = "Seattle",
    TravelDate = $"{DateTime.UtcNow.AddDays(1):yyyy-MM-dd}"
};

var sut = new BookingDialog();
var testClient = new DialogTestClient(Channels.Msteams, sut, inputDialogParams);

BookingDialog reçoit ce paramètre et y accède dans le test de la même façon que lors de son appel à partir de MainDialog.

private async Task<DialogTurnResult> DestinationStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
    var bookingDetails = (BookingDetails)stepContext.Options;
    ...
}

const inputDialogParams = {
    destination: 'Seattle',
    travelDate: formatDate(new Date().setDate(now.getDate() + 1))
};

const sut = new BookingDialog();
const testClient = new DialogTestClient('msteams', sut, inputDialogParams);

BookingDialog reçoit ce paramètre et peut y accèder dans le test de la même façon que s’il avait été appelé à partir de MainDialog.

async destinationStep(stepContext) {
    const bookingDetails = stepContext.options;
    ...
}

Certaines boîtes de dialogue telles que BookingDialog ou DateResolverDialog retournent une valeur à la boîte de dialogue appelante. L’objet DialogTestClient expose une propriété DialogTurnResult qui peut être utilisée pour analyser et déclarer les résultats retournés par la boîte de dialogue.

Par exemple :

var sut = new BookingDialog();
var testClient = new DialogTestClient(Channels.Msteams, sut);

var reply = await testClient.SendActivityAsync<IMessageActivity>("hi");
Assert.Equal("Where would you like to travel to?", reply.Text);

...

var bookingResults = (BookingDetails)testClient.DialogTurnResult.Result;
Assert.Equal("New York", bookingResults?.Origin);
Assert.Equal("Seattle", bookingResults?.Destination);
Assert.Equal("2019-06-21", bookingResults?.TravelDate);

La propriété DialogTurnResult peut également être utilisée pour inspecter et déclarer les résultats intermédiaires retournés par les étapes d’une cascade.

Certaines boîtes de dialogue telles que BookingDialog ou DateResolverDialog retournent une valeur à la boîte de dialogue appelante. L’objet DialogTestClient expose une propriété dialogTurnResult qui peut être utilisée pour analyser et déclarer les résultats retournés par la boîte de dialogue.

Par exemple :

const sut = new BookingDialog();
const testClient = new DialogTestClient('msteams', sut);

let reply = await testClient.sendActivity('hi');
assert.strictEqual(reply.text, 'Where would you like to travel to?');

...

const bookingResults = client.dialogTurnResult.result;
assert.strictEqual('New York', bookingResults.destination);
assert.strictEqual('Seattle', bookingResults.origin);
assert.strictEqual('2019-06-21', bookingResults.travelDate);

La propriété dialogTurnResult peut également être utilisée pour inspecter et déclarer les résultats intermédiaires retournés par les étapes d’une cascade.

Le package Microsoft.Bot.Builder.Testing comprend un XUnitDialogTestLogger qui enregistre les messages envoyés et reçus par la boîte de dialogue dans la console.

Pour utiliser cet intergiciel, votre test doit exposer un constructeur qui reçoit un objet ITestOutputHelper fourni par le Test Runner XUnit et créer un XUnitDialogTestLogger qui sera passé à DialogTestClient par le biais du paramètre middlewares.

public class BookingDialogTests
{
    private readonly IMiddleware[] _middlewares;

    public BookingDialogTests(ITestOutputHelper output)
        : base(output)
    {
        _middlewares = new[] { new XUnitDialogTestLogger(output) };
    }

    [Fact]
    public async Task SomeBookingDialogTest()
    {
        // Arrange
        var sut = new BookingDialog();
        var testClient = new DialogTestClient(Channels.Msteams, sut, middlewares: _middlewares);

        ...
    }
}

Voici un exemple de la façon dont XUnitDialogTestLogger se connecte à la fenêtre de sortie lorsqu'il est configuré :

Pour plus d’informations sur l’envoi d’une sortie de test à la console lors de l’utilisation de XUnit, consultez Capture de la sortie dans la documentation XUnit.

Le package botbuilder-testing inclut un DialogTestLogger qui connecte les messages envoyés et reçus par la boîte de dialogue à la console.

Pour utiliser cet intergiciel, transmettez-le à DialogTestClient à partir du paramètre middlewares.

const client = new DialogTestClient('msteams', sut, testData.initialData, [new DialogTestLogger()]);

Voici un exemple de la façon dont DialogTestLogger se connecte à la fenêtre de sortie lorsqu'il est configuré :

Dans l’exemple CoreBot, nous utilisons des tests Theory de XUnit pour paramétrer des tests.

Tests de théorie utilisant InlineData

Le test suivant vérifie qu'une boîte de dialogue est annulée lorsque l'utilisateur dit « annuler ».

[Fact]
public async Task ShouldBeAbleToCancel()
{
    var sut = new TestCancelAndHelpDialog();
    var testClient = new DialogTestClient(Channels.Test, sut);

    var reply = await testClient.SendActivityAsync<IMessageActivity>("Hi");
    Assert.Equal("Hi there", reply.Text);
    Assert.Equal(DialogTurnStatus.Waiting, testClient.DialogTurnResult.Status);

    reply = await testClient.SendActivityAsync<IMessageActivity>("cancel");
    Assert.Equal("Cancelling...", reply.Text);
}

Pour annuler une boîte de dialogue, les utilisateurs peuvent saisir « quitter », « ignorer » et « arrêter ». Au lieu d'écrire un nouveau cas de test pour chaque mot possible, écrivez une méthode de test Theory unique qui accepte des paramètres via une liste de valeurs InlineData pour définir les paramètres de chaque cas de test :

[Theory]
[InlineData("cancel")]
[InlineData("quit")]
[InlineData("never mind")]
[InlineData("stop it")]
public async Task ShouldBeAbleToCancel(string cancelUtterance)
{
    var sut = new TestCancelAndHelpDialog();
    var testClient = new DialogTestClient(Channels.Test, sut, middlewares: _middlewares);

    var reply = await testClient.SendActivityAsync<IMessageActivity>("Hi");
    Assert.Equal("Hi there", reply.Text);
    Assert.Equal(DialogTurnStatus.Waiting, testClient.DialogTurnResult.Status);

    reply = await testClient.SendActivityAsync<IMessageActivity>(cancelUtterance);
    Assert.Equal("Cancelling...", reply.Text);
}

Le nouveau test sera exécuté quatre fois avec les différents paramètres et chaque cas sera affiché en tant qu'élément enfant sous le test ShouldBeAbleToCancel dans l'Explorateur de tests Visual Studio. Si l'un d'eux échoue, comme indiqué ci-dessous, vous pouvez cliquer avec le bouton de droite et déboguer le scénario qui a échoué au lieu de exécute à nouveau l'ensemble complet des tests.

Tests de théorie utilisant des types MemberData et complexes

InlineData est utile pour les tests pilotés par les données de petite taille qui reçoivent des paramètres de type valeur simples (chaîne, int, etc.).

La BookingDetails reçoit un objet BookingDialog et retourne un nouvel objet BookingDetails. Une version non paramétrable d’un test pour cette boîte de dialogue doit se présenter comme suit :

[Fact]
public async Task DialogFlow()
{
    // Initial parameters
    var initialBookingDetails = new BookingDetails
    {
        Origin = "Seattle",
        Destination = null,
        TravelDate = null,
    };

    // Expected booking details
    var expectedBookingDetails = new BookingDetails
    {
        Origin = "Seattle",
        Destination = "New York",
        TravelDate = "2019-06-25",
    };

    var sut = new BookingDialog();
    var testClient = new DialogTestClient(Channels.Test, sut, initialBookingDetails);

    // Act/Assert
    var reply = await testClient.SendActivityAsync<IMessageActivity>("hi");
    ...

    var bookingResults = (BookingDetails)testClient.DialogTurnResult.Result;
    Assert.Equal(expectedBookingDetails.Origin, bookingResults?.Origin);
    Assert.Equal(expectedBookingDetails.Destination, bookingResults?.Destination);
    Assert.Equal(expectedBookingDetails.TravelDate, bookingResults?.TravelDate);
}

Pour paramétrer ce test, nous avons créé une classe BookingDialogTestCase qui contient les données de notre cas de test. Il contient l’objet BookingDetails initial, l’objet BookingDetails attendu et un tableau de chaînes contenant les énoncés envoyés par l’utilisateur et les réponses attendues de la boîte de dialogue pour chaque tour.

public class BookingDialogTestCase
{
    public BookingDetails InitialBookingDetails { get; set; }

    public string[,] UtterancesAndReplies { get; set; }

    public BookingDetails ExpectedBookingDetails { get; set; }
}

Nous avons également créé une classe BookingDialogTestsDataGenerator d’assistance exposant une méthode IEnumerable<object[]> BookingFlows() qui retourne une collection des cas de test à utiliser par le test.

Pour afficher chaque cas de test sous la forme d’un élément distinct dans l’Explorateur de tests Visual Studio, le Test Runner XUnit requiert que les types complexes tels que BookingDialogTestCase implémentent IXunitSerializable, pour simplifier cela, l'infrastructure Bot.Builder.Testing fournit un classe TestDataObject qui implémente cette interface et qui peut être utilisée pour inclure dans un wrapper les données de cas de test sans avoir à implémenter IXunitSerializable.

Voici un fragment de IEnumerable<object[]> BookingFlows() qui montre comment les deux classes sont utilisées :

public static class BookingDialogTestsDataGenerator
{
    public static IEnumerable<object[]> BookingFlows()
    {
        // Create the first test case object
        var testCaseData = new BookingDialogTestCase
        {
            InitialBookingDetails = new BookingDetails(),
            UtterancesAndReplies = new[,]
            {
                { "hi", "Where would you like to travel to?" },
                { "Seattle", "Where are you traveling from?" },
                { "New York", "When would you like to travel?" },
                { "tomorrow", $"Please confirm, I have you traveling to: Seattle from: New York on: {DateTime.Now.AddDays(1):yyyy-MM-dd}. Is this correct? (1) Yes or (2) No" },
                { "yes", null },
            },
            ExpectedBookingDetails = new BookingDetails
            {
                Destination = "Seattle",
                Origin = "New York",
                TravelDate = $"{DateTime.Now.AddDays(1):yyyy-MM-dd}",
            }, 
        };
        // wrap the test case object into TestDataObject and return it.
        yield return new object[] { new TestDataObject(testCaseData) };

        // Create the second test case object
        testCaseData = new BookingDialogTestCase
        {
            InitialBookingDetails = new BookingDetails
            {
                Destination = "Seattle",
                Origin = "New York",
                TravelDate = null,
            },
            UtterancesAndReplies = new[,]
            {
                { "hi", "When would you like to travel?" },
                { "tomorrow", $"Please confirm, I have you traveling to: Seattle from: New York on: {DateTime.Now.AddDays(1):yyyy-MM-dd}. Is this correct? (1) Yes or (2) No" },
                { "yes", null },
            },
            ExpectedBookingDetails = new BookingDetails
            {
                Destination = "Seattle",
                Origin = "New York",
                TravelDate = $"{DateTime.Now.AddDays(1):yyyy-MM-dd}",
            },
        };
        // wrap the test case object into TestDataObject and return it.
        yield return new object[] { new TestDataObject(testCaseData) };
    }
}

Une fois que nous avons créé un objet pour stocker les données de test et une classe qui expose une collection de cas de test, nous utilisons l’attribut MemberData de XUnit au lieu de InlineData pour alimenter les données dans le test, le premier paramètre pour MemberData est le nom de la fonction statique qui retourne la collection de cas de test et le deuxième paramètre est le type de classe qui expose cette méthode.

[Theory]
[MemberData(nameof(BookingDialogTestsDataGenerator.BookingFlows), MemberType = typeof(BookingDialogTestsDataGenerator))]
public async Task DialogFlowUseCases(TestDataObject testData)
{
    // Get the test data instance from TestDataObject
    var bookingTestData = testData.GetObject<BookingDialogTestCase>();
    var sut = new BookingDialog();
    var testClient = new DialogTestClient(Channels.Test, sut, bookingTestData.InitialBookingDetails);

    // Iterate over the utterances and replies array.
    for (var i = 0; i < bookingTestData.UtterancesAndReplies.GetLength(0); i++)
    {
        var reply = await testClient.SendActivityAsync<IMessageActivity>(bookingTestData.UtterancesAndReplies[i, 0]);
        Assert.Equal(bookingTestData.UtterancesAndReplies[i, 1], reply?.Text);
    }

    // Assert the resulting BookingDetails object
    var bookingResults = (BookingDetails)testClient.DialogTurnResult.Result;
    Assert.Equal(bookingTestData.ExpectedBookingDetails?.Origin, bookingResults?.Origin);
    Assert.Equal(bookingTestData.ExpectedBookingDetails?.Destination, bookingResults?.Destination);
    Assert.Equal(bookingTestData.ExpectedBookingDetails?.TravelDate, bookingResults?.TravelDate);
}

Voici un exemple des résultats des tests DialogFlowUseCases dans l'Explorateur de tests Visual Studio lorsque le test est exécuté :

Tests simples pilotés par les données

Le test suivant vérifie qu'une boîte de dialogue est annulée lorsque l'utilisateur dit « annuler ».

describe('ShouldBeAbleToCancel', () => {
    it('Should cancel', async () => {
        const sut = new TestCancelAndHelpDialog();
        const client = new DialogTestClient('test', sut, null, [new DialogTestLogger()]);

        // Execute the test case
        let reply = await client.sendActivity('Hi');
        assert.strictEqual(reply.text, 'Hi there');
        assert.strictEqual(client.dialogTurnResult.status, 'waiting');

        reply = await client.sendActivity('cancel');
        assert.strictEqual(reply.text, 'Cancelling...');
    });
});

Supposons que, plus tard, nous devons être en mesure de gérer d’autres énoncés d’annulation, comme « quitter », « ignorer » et « arrêter ». Au lieu d'écrire trois tests plus répétitifs pour chaque nouvel énoncé, nous pouvons refactoriser le test pour utiliser une liste d'énoncés afin de définir les paramètres de chaque cas de test :

describe('ShouldBeAbleToCancel', () => {
    const testCases = ['cancel', 'quit', 'never mind', 'stop it'];

    testCases.map(testData => {
        it(testData, async () => {
            const sut = new TestCancelAndHelpDialog();
            const client = new DialogTestClient('test', sut, null, [new DialogTestLogger()]);

            // Execute the test case
            let reply = await client.sendActivity('Hi');
            assert.strictEqual(reply.text, 'Hi there');
            assert.strictEqual(client.dialogTurnResult.status, 'waiting');

            reply = await client.sendActivity(testData);
            assert.strictEqual(reply.text, 'Cancelling...');
        });
    });
});

Le nouveau test sera exécuté quatre fois avec les différents paramètres et chaque cas sera affiché en tant qu'élément enfant sous le test ShouldBeAbleToCancel dans l'Explorateur de tests Mocha. Si l'un d'eux échoue, comme indiqué ci-dessous, vous pouvez exécuter et déboguer le scénario qui a échoué au lieu de d'exécuter à nouveau l'ensemble complet des tests.

Tests pilotés par les données avec des types complexes

L'utilisation d'une liste d'énoncés simple est utile pour les tests pilotés par les données de petite taille qui reçoivent des paramètres de type valeur simples (chaîne, int, etc.) ou des petits objets.

La BookingDetails reçoit un objet BookingDialog et retourne un nouvel objet BookingDetails. Une version non paramétrable d’un test pour cette boîte de dialogue doit se présenter comme suit :

describe('BookingDialog', () => {
    it('Returns expected booking details', async () => {
        // Initial parameters
        const initialBookingDetails = {
            origin: 'Seattle',
            destination: undefined,
            travelDate: undefined
        };

        // Expected booking details
        const expectedBookingDetails = {
            origin: 'Seattle',
            destination: 'New York',
            travelDate: '2019-06-25'
        };

        const sut = new BookingDialog('bookingDialog');
        const client = new DialogTestClient('test', sut, initialBookingDetails, [new DialogTestLogger()]);

        // Execute the test case
        const reply = await client.sendActivity('Hi');
        ...

        // Check dialog results
        const result = client.dialogTurnResult.result;
        assert.strictEqual(result.destination, expectedBookingDetails.destination);
        assert.strictEqual(result.origin, expectedBookingDetails.origin);
        assert.strictEqual(result.travelDate, expectedBookingDetails.travelDate);
    });
});

Pour paramétrer ce test, nous avons créé un module bookingDialogTestCases qui renvoie les données du cas de test. Chaque élément contient un nom de cas de test, l’objet « BookingDetails » initial, le « BookingDetails » attendu et un tableau de chaînes avec les énoncés envoyés depuis l’utilisateur et les réponses attendues de la boîte de dialogue pour chaque tour.

module.exports = [
    // Create the first test case object
    {
        name: 'Full flow',
        initialData: {},
        steps: [
            ['hi', 'To what city would you like to travel?'],
            ['Seattle', 'From what city will you be travelling?'],
            ['New York', 'On what date would you like to travel?'],
            ['tomorrow', `Please confirm, I have you traveling to: Seattle from: New York on: ${ tomorrow }. Is this correct? (1) Yes or (2) No`],
            ['yes', null]
        ],
        expectedResult: {
            destination: 'Seattle',
            origin: 'New York',
            travelDate: tomorrow
        }
    },
    // Create the second test case object
    {
        name: 'Destination and Origin provided',
        initialData: {
            destination: 'Seattle',
            origin: 'New York'
        },
        steps: [
            ['hi', 'On what date would you like to travel?'],
            ['tomorrow', `Please confirm, I have you traveling to: Seattle from: New York on: ${ tomorrow }. Is this correct? (1) Yes or (2) No`],
            ['yes', null]
        ],
        expectedStatus: 'complete',
        expectedResult: {
            destination: 'Seattle',
            origin: 'New York',
            travelDate: tomorrow
        }
    }
];

Une fois que nous avons créé la liste qui contient les données de test, nous pouvons refactoriser notre test pour mapper cette liste à des cas de test individuels.

describe('DialogFlowUseCases', () => {
    const testCases = require('./testData/bookingDialogTestCases.js');

    testCases.map(testData => {
        it(testData.name, async () => {
            const sut = new BookingDialog('bookingDialog');
            const client = new DialogTestClient('test', sut, testData.initialData, [new DialogTestLogger()]);

            // Execute the test case
            for (let i = 0; i < testData.steps.length; i++) {
                const reply = await client.sendActivity(testData.steps[i][0]);
                assert.strictEqual((reply ? reply.text : null), testData.steps[i][1]);
            }

            // Check dialog results
            const actualResult = client.dialogTurnResult.result;
            assert.strictEqual(actualResult.destination, testData.expectedResult.destination);
            assert.strictEqual(actualResult.origin, testData.expectedResult.origin);
            assert.strictEqual(actualResult.travelDate, testData.expectedResult.travelDate);
        });
    });
});

Voici un exemple des résultats de la suite de tests DialogFlowUseCases dans l'Explorateur de tests Mocha lorsque le test est exécuté :

public MainDialog()
    : base(nameof(MainDialog))
{
    ...
    AddDialog(new BookingDialog());
    ...
}

constructor() {
    super('MainDialog');
    ...
    this.addDialog(new BookingDialog('bookingDialog'));
    ...
}

public MainDialog(BookingDialog bookingDialog)
    : base(nameof(MainDialog))
{
    ...
    AddDialog(bookingDialog);
    ...
}

constructor(bookingDialog) {
    super('MainDialog');
    ...
    this.addDialog(bookingDialog);
    ...
}

// Create the mock object
var mockDialog = new Mock<BookingDialog>();

// Use the mock object to instantiate MainDialog
var sut = new MainDialog(mockDialog.Object);

var testClient = new DialogTestClient(Channels.Test, sut);

// Create the mock object
const mockDialog = new MockBookingDialog();

// Use the mock object to instantiate MainDialog
const sut = new MainDialog(mockDialog);

const testClient = new DialogTestClient('test', sut);

// Create the mock object for BookingDialog.
var mockDialog = new Mock<BookingDialog>();
mockDialog
    .Setup(x => x.BeginDialogAsync(It.IsAny<DialogContext>(), It.IsAny<object>(), It.IsAny<CancellationToken>()))
    .Returns(async (DialogContext dialogContext, object options, CancellationToken cancellationToken) =>
    {
        // Send a generic activity so we can assert that the dialog was invoked.
        await dialogContext.Context.SendActivityAsync($"{mockDialogNameTypeName} mock invoked", cancellationToken: cancellationToken);

        // Create the BookingDetails instance we want the mock object to return.
        var expectedBookingDialogResult = new BookingDetails()
        {
            Destination = "Seattle",
            Origin = "New York",
            TravelDate = $"{DateTime.UtcNow.AddDays(1):yyyy-MM-dd}"
        };

        // Return the BookingDetails we need without executing the dialog logic.
        return await dialogContext.EndDialogAsync(expectedBookingDialogResult, cancellationToken);
    });

// Create the sut (System Under Test) using the mock booking dialog.
var sut = new MainDialog(mockDialog.Object);

Dans cet exemple, nous avons utilisé Moq pour créer la boîte de dialogue fictive et les méthodes Setup et Returns pour configurer son comportement.

class MockBookingDialog extends BookingDialog {
    constructor() {
        super('bookingDialog');
    }

    async beginDialog(dc, options) {
        // Send a generic activity so we can assert that the dialog was invoked.
        await dc.context.sendActivity(`${ this.id } mock invoked`);

        // Create the BookingDetails instance we want the mock object to return.
        const bookingDetails = {
            origin: 'New York',
            destination: 'Seattle',
            travelDate: '2025-07-08'
        };

        // Return the BookingDetails we need without executing the dialog logic.
        return await dc.endDialog(bookingDetails);
    }
}
...
// Create the sut (System Under Test) using the mock booking dialog.
const sut = new MainDialog(new MockBookingDialog());
...

Dans cet exemple, nous implémentons la boîte de dialogue fictive en dérivant de BookingDialog et en remplaçant la méthode beginDialog pour contourner la logique de la boîte de dialogue sous-jacente.

var mockRecognizer = new Mock<IRecognizer>();
mockRecognizer
    .Setup(x => x.RecognizeAsync<FlightBooking>(It.IsAny<ITurnContext>(), It.IsAny<CancellationToken>()))
    .Returns(() =>
    {
        var luisResult = new FlightBooking
        {
            Intents = new Dictionary<FlightBooking.Intent, IntentScore>
            {
                { FlightBooking.Intent.BookFlight, new IntentScore() { Score = 1 } },
            },
            Entities = new FlightBooking._Entities(),
        };
        return Task.FromResult(luisResult);
    });

// Create a mock class for the recognizer that overrides executeLuisQuery.
class MockFlightBookingRecognizer extends FlightBookingRecognizer {
    constructor(mockResult) {
        super();
        this.mockResult = mockResult;
    }

    async executeLuisQuery(context) {
        return this.mockResult;
    }
}
...
// Create a mock result from a string
const mockLuisResult = JSON.parse(`{"intents": {"BookFlight": {"score": 1}}, "entities": {"$instance": {}}}`);
// Use the mock result with the mock recognizer.
const mockRecognizer = new MockFlightBookingRecognizer(mockLuisResult);
...

var mockRecognizer = new Mock<IRecognizer>();
mockRecognizer
    .Setup(x => x.RecognizeAsync<FlightBooking>(It.IsAny<ITurnContext>(), It.IsAny<CancellationToken>()))
    .Returns(() =>
    {
        // Deserialize the LUIS result from embedded json file in the TestData folder.
        var bookingResult = GetEmbeddedTestData($"{GetType().Namespace}.TestData.FlightToMadrid.json");

        // Return the deserialized LUIS result.
        return Task.FromResult(bookingResult);
    });

// Create a mock result from a json file
const mockLuisResult = require(`./testData/FlightToMadrid.json`);
// Use the mock result with the mock recognizer.
const mockRecognizer = new MockFlightBookingRecognizer(mockLuisResult);