Tesztrobotok egyesének használata

A KÖVETKEZŐKRE VONATKOZIK: SDK v4

Ebben a témakörben bemutatjuk, hogyan:

• Egységtesztek létrehozása robotokhoz.
• Az érvényesség használatával ellenőrizze, hogy a párbeszédpanel által visszaadott tevékenységek a várt értékekkel ellentétesek-e.
• Az érvényesség használatával ellenőrizze a párbeszédpanel által visszaadott eredményeket.
• Különböző típusú adatvezérelt tesztek létrehozása.
• Hozzon létre mintaobjektumokat a párbeszédpanel különböző függőségeihez, például a nyelv felismerőihez stb.

Előfeltételek

C#

A jelen témakörben használt CoreBot-tesztek mintája a Microsoft.Bot.Builder.Testing csomagra, az XUnitra és a Moq-ra hivatkozik az egységtesztek létrehozásához.

JavaScript

A jelen témakörben használt CoreBot-tesztek mintája a robotépítő-tesztelési csomagra, a Mocha egységtesztek létrehozására, a Mocha Test Explorer pedig a VS Code teszteredményeinek vizualizációjára hivatkozik.

Az alapvető robotminta a Language Understanding (LUIS) használatával azonosítja a felhasználói szándékokat; A felhasználói szándék azonosítása azonban nem a jelen cikk középpontjában van. A felhasználói szándékok azonosításával kapcsolatos információkért tekintse meg a természetes nyelv megértését és a természetes nyelv megértésének hozzáadását a robothoz.

Megjegyzés:

A Language Understanding (LUIS) 2025. október 1-jén megszűnik. 2023. április 1-től nem hozhat létre új LUIS-erőforrásokat. Az Azure AI Language részeként már elérhető a nyelvértés újabb verziója.

Az Azure AI Language egyik funkciója, a beszélgetési nyelv megértése (CLU) a LUIS frissített verziója. További információ a Bot Framework SDK nyelvfelismerési támogatásáról: Természetes nyelvfelismerés.

Tesztelési párbeszédpanelek

A CoreBot-mintában a párbeszédpanelek tesztelése az DialogTestClient osztályon keresztül történik, amely lehetővé teszi, hogy a roboton kívül elkülönítve tesztelje őket, és anélkül, hogy a kódot egy webszolgáltatásban kellene üzembe helyeznie.

Ebben az osztályban olyan egységteszteket írhat, amelyek felváltva ellenőrzik a párbeszédpanelek válaszait. Az osztályt használó DialogTestClient egységteszteknek más, a robotépítő párbeszédpanelek kódtárával létrehozott párbeszédpanelekkel kell működnie.

Az alábbi példa a következőből DialogTestClientszármaztatott teszteket mutatja be:

C#

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

Az DialogTestClient osztály a Microsoft.Bot.Builder.Testing névtérben van definiálva, és a Microsoft.Bot.Builder.Testing NuGet csomag része.

JavaScript

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

Az DialogTestClient osztály szerepel a botbuilder-testing npm csomagban.

DialogTestClient

A célcsatorna első paramétere DialogTestClient . Ez lehetővé teszi, hogy a robot célcsatornája (Teams, Slack stb.) alapján tesztelje a különböző renderelési logikát. Ha bizonytalan a célcsatornával kapcsolatban, használhatja a Emulator vagy Test csatornaazonosítókat, de ne feledje, hogy egyes összetevők eltérően viselkedhetnek az aktuális csatornától függően, ConfirmPrompt például az Igen/Nem beállításokat másként jeleníti meg a csatornák és Emulator a Test csatornák esetében. Ezzel a paraméterel a feltételes renderelési logikát is tesztelheti a párbeszédpanelen a csatornaazonosító alapján.

A második paraméter a tesztelt párbeszédpanel egy példánya. A cikkben sut szereplő mintakód a tesztelt rendszert jelöli.

A DialogTestClient konstruktor további paramétereket biztosít, amelyek lehetővé teszik az ügyfél viselkedésének további testreszabását, vagy paraméterek átadását a tesztelt párbeszédpanelre, ha szükséges. A párbeszédpanel inicializálási adatait átadhatja, egyéni köztes szoftvereket adhat hozzá, vagy használhatja a saját TestAdapter és ConversationState -példányát.

Üzenetek küldése és fogadása

C#

A SendActivityAsync<IActivity> metódus lehetővé teszi, hogy szöveges kimondott szöveget vagy egy IActivity üzenetet küldjön a párbeszédpanelre, és visszaadja az első kapott üzenetet. A <T> paraméter a válasz erős gépelt példányának visszaadására szolgál, így anélkül érvényesítheti, hogy el kellene adnia.

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

Bizonyos esetekben a robot több üzenetet is küldhet egyetlen tevékenységre válaszul, ezekben az esetekben DialogTestClient a válaszok várólistára kerülnek, és a GetNextReply<IActivity> metódussal a következő üzenetet a válaszsorból jelenítheti meg.

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

GetNextReply<IActivity> null értéket ad vissza, ha nincsenek további üzenetek a válaszsorban.

JavaScript

A sendActivity metódus lehetővé teszi, hogy szöveges kimondott szöveget vagy egy Activity üzenetet küldjön a párbeszédpanelre, és visszaadja az első kapott üzenetet.

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

Bizonyos esetekben a robot több üzenetet is küldhet egyetlen tevékenységre válaszul, ezekben az esetekben DialogTestClient a válaszok várólistára kerülnek, és a getNextReply metódussal a következő üzenetet a válaszsorból jelenítheti meg.

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

getNextReply null értéket ad vissza, ha nincsenek további üzenetek a válaszsorban.

Tevékenységek érvényesítése

C#

A CoreBot-mintában szereplő kód csak a Text visszaadott tevékenységek tulajdonságát érvényesíti. Összetettebb robotok esetén érdemes lehet más tulajdonságokat is érvényesíteni, például Speak, InputHint, ChannelDatastb.

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

Ezt úgy teheti meg, hogy egyenként ellenőrzi az egyes tulajdonságokat a fent látható módon, saját segédeszközöket írhat a tevékenységek érvényesítéséhez, vagy használhat más keretrendszereket, például a FluentAssertionst egyéni állítások írásához és a tesztkód egyszerűsítéséhez.

JavaScript

A CoreBot-mintában szereplő kód csak a text visszaadott tevékenységek tulajdonságát érvényesíti. Összetettebb robotok esetén érdemes lehet más tulajdonságokat is érvényesíteni, például speak, inputHint, channelDatastb.

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

Ezt úgy teheti meg, hogy egyenként ellenőrzi az egyes tulajdonságokat a fent látható módon, saját segédeszközöket írhat az érvényesítési tevékenységekhez, vagy más kódtárak, például Chai használatával egyéni állításokat írhat, és egyszerűsítheti a tesztkódot.

Paraméterek átadása a párbeszédpanelekre

A DialogTestClient konstruktor rendelkezik egy initialDialogOptions olyan szerkezettel, amellyel paramétereket adhat át a párbeszédpanelnek. Ebben a MainDialog mintában például inicializál egy BookingDetails objektumot a nyelvfelismerési eredményekből, a felhasználó kimondott szövegéből feloldott entitásokkal, és átadja ezt az objektumot a meghíváshoz BookingDialog.

Ezt egy tesztben az alábbiak szerint valósíthatja meg:

C#

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 fogadja ezt a paramétert, és ugyanúgy éri el a tesztben, mint a parancsból MainDialogvaló meghíváskor.

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

JavaScript

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

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

BookingDialog megkapja ezt a paramétert, és ugyanúgy érheti el a tesztben, mintha meghívták MainDialogvolna.

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

Az érvényesítési párbeszédpanel az eredmények megjelenítését

C#

Egyes párbeszédpanelek egy értéket szeretnek BookingDialog vagy DateResolverDialog visszaadnak a hívó párbeszédpanelnek. Az DialogTestClient objektum egy DialogTurnResult tulajdonságot tesz elérhetővé, amely a párbeszédpanel által visszaadott eredmények elemzésére és érvényesítésére használható.

Például:

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

A DialogTurnResult tulajdonság a vízesés lépései által visszaadott köztes eredmények vizsgálatára és érvényesítésére is használható.

JavaScript

Egyes párbeszédpanelek egy értéket szeretnek BookingDialog vagy DateResolverDialog visszaadnak a hívó párbeszédpanelnek. Az DialogTestClient objektum egy dialogTurnResult tulajdonságot tesz elérhetővé, amely a párbeszédpanel által visszaadott eredmények elemzésére és érvényesítésére használható.

Például:

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

A dialogTurnResult tulajdonság a vízesés lépései által visszaadott köztes eredmények vizsgálatára és érvényesítésére is használható.

Tesztkimenet elemzése

Néha szükség van egy egységteszt átiratának olvasására a teszt végrehajtásának elemzéséhez anélkül, hogy hibakeresést kellene végeznie a teszten.

C#

A Microsoft.Bot.Builder.Testing csomag egy XUnitDialogTestLogger olyan csomagot tartalmaz, amely naplózza a párbeszédpanel által a konzolra küldött és fogadott üzeneteket.

A köztes szoftver használatához a tesztnek közzé kell tennie egy konstruktort, amely megkapja ITestOutputHelper az XUnit tesztfuttató által biztosított objektumot, és létre kell hoznia egy XUnitDialogTestLogger olyan objektumot, amely a paraméteren keresztül middlewares lesz átadvaDialogTestClient.

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

        ...
    }
}

Íme egy példa a XUnitDialogTestLogger kimeneti ablak naplóinak konfigurálásakor:

A tesztkimenetnek az XUnit használatakor a konzolra való küldésével kapcsolatos további információkért lásd : Kimenet rögzítése az XUnit dokumentációjában.

JavaScript

A botbuilder-tesztelési csomag tartalmaz egy DialogTestLogger olyan csomagot, amely naplózza a párbeszédpanel által a konzolra küldött és fogadott üzeneteket.

A köztes szoftver használatához adja át DialogTestClient a middlewares paraméteren keresztül.

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

Íme egy példa a DialogTestLogger kimeneti ablak naplóinak konfigurálásakor:

A rendszer ezt a kimenetet a buildkiszolgálón is naplózza a folyamatos integrációs buildek során, és segít a buildelési hibák elemzésében.

Adatvezérelt tesztek

A legtöbb esetben a párbeszédpanel logikája nem változik, és a beszélgetés különböző végrehajtási útvonalai a felhasználói kimondott szövegeken alapulnak. Ahelyett, hogy egyetlen egységtesztet írnál az egyes változatokhoz a beszélgetésben, egyszerűbb az adatvezérelt tesztek (más néven paraméteres teszt) használata.

A dokumentum áttekintési szakaszában található mintateszt például bemutatja, hogyan tesztelhet egy végrehajtási folyamatot, másokat azonban nem, például:

• Mi történik, ha a felhasználó nemet mond a megerősítésre?
• Mi a teendő, ha más dátumot használnak?

Az adatvezérelt tesztek lehetővé teszik ezeknek a permutációknak a tesztelését anélkül, hogy újra kellene írni a teszteket.

C#

A CoreBot-mintában az XUnit tesztjeit használjuk Theory a tesztek paraméterezéséhez.

Elméleti tesztek az InlineData használatával

Az alábbi teszt ellenőrzi, hogy a rendszer megszakít-e egy párbeszédpanelt, amikor a felhasználó a "mégse" szöveget mondja.

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

A párbeszédpanel megszakításához a felhasználók beírhatják a "kilépés", a "nem bánom" és a "stop it" szöveget. Ahelyett, hogy minden lehetséges szóhoz új tesztesetet írnál, írjon egyetlen Theory tesztmetódust, amely az értékek listájával InlineData fogadja el a paramétereket az egyes tesztesetek paramétereinek meghatározásához:

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

Az új teszt négyszer lesz végrehajtva a különböző paraméterekkel, és minden eset gyermekelemként jelenik meg a ShouldBeAbleToCancel Visual Studio Test Explorer tesztje alatt. Ha bármelyikük meghiúsul az alább látható módon, a teljes tesztkészlet újrafuttatása helyett a jobb gombbal rákattinthat és hibakeresést végezhet a sikertelen forgatókönyvben.

Elméleti tesztek MemberData és összetett típusok használatával

InlineData olyan kis adatvezérelt tesztekhez hasznos, amelyek egyszerű értéktípus-paramétereket (sztring, int stb.) kapnak.

A BookingDialog rendszer kap egy BookingDetails objektumot, és egy új BookingDetails objektumot ad vissza. A párbeszédpanel tesztjének nem paraméteres verziója a következőképpen nézne ki:

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

A teszt paraméterezéséhez létrehoztunk egy osztályt BookingDialogTestCase , amely tartalmazza a teszteset adatait. Tartalmazza a kezdeti BookingDetails objektumot, a várt BookingDetails és egy sztringtömböt, amely tartalmazza a felhasználótól küldött kimondott szövegeket, valamint az egyes fordulókhoz tartozó párbeszédpanel várt válaszait.

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

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

    public BookingDetails ExpectedBookingDetails { get; set; }
}

Létrehoztunk egy segédosztályt BookingDialogTestsDataGenerator is, amely egy metódust IEnumerable<object[]> BookingFlows() tesz elérhetővé, amely visszaadja a teszt által használandó tesztesetek gyűjteményét.

Ahhoz, hogy az egyes teszteseteket külön elemként jelenítse meg a Visual Studio Test Explorerben, az XUnit tesztfuttatónak olyan összetett típusokra van szüksége, mint BookingDialogTestCase a implementálás IXunitSerializable– ennek leegyszerűsítéséhez a Bot.Builder.Testing keretrendszer egy olyan osztályt TestDataObject biztosít, amely implementálja ezt a felületet, és a teszteset adatainak implementálása IXunitSerializablenélkül is becsomagolható.

Íme egy töredék IEnumerable<object[]> BookingFlows() , amely bemutatja, hogyan használja a két osztályt:

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

Miután létrehozunk egy objektumot a tesztadatok tárolására, és egy olyan osztályt hozunk létre, amely tesztesetek gyűjteményét teszi elérhetővé, az XUnit MemberData attribútumot használjuk ahelyett InlineData , hogy az adatokat a tesztbe táplálnánk, az első paraméter a MemberData statikus függvény neve, amely visszaadja a tesztelési esetek gyűjteményét, a második paraméter pedig a metódust elérhetővé tevő osztály típusa.

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

Íme egy példa a DialogFlowUseCases Visual Studio Test Explorer tesztjeinek eredményeire a teszt végrehajtásakor:

JavaScript

Egyszerű adatvezérelt tesztek

Az alábbi teszt ellenőrzi, hogy a rendszer megszakít-e egy párbeszédpanelt, amikor a felhasználó a "mégse" szöveget mondja.

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

Vegye figyelembe, hogy később képesnek kell lennie más kimondott szövegek kezelésére a lemondáshoz, például a "kilépéshez", a "nem bánom" és a "stop it" kifejezéshez. Ahelyett, hogy minden új kimondott szöveghez további három ismétlődő tesztet írnánk, újrafunkálhatjuk a tesztet a kimondott szövegek listájának használatával az egyes tesztesetek paramétereinek meghatározásához:

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

Az új teszt négyszer lesz végrehajtva a különböző paraméterekkel, és minden eset gyermekelemként jelenik meg a ShouldBeAbleToCancel Mocha Test Explorer tesztcsomagjában. Ha bármelyikük sikertelen, ahogy az alább látható, a teljes tesztkészlet újrafuttatása helyett futtathatja és hibakeresésre használhatja a sikertelen forgatókönyvet.

Adatvezérelt tesztek összetett típusokkal

A kimondott szövegek egyszerű listájának használata olyan kis adatvezérelt tesztekhez hasznos, amelyek egyszerű értéktípus-paramétereket (sztring, int stb.) vagy kis objektumokat kapnak.

A BookingDialog rendszer kap egy BookingDetails objektumot, és egy új BookingDetails objektumot ad vissza. A párbeszédpanel tesztjének nem paraméterezett verziója a következőképpen nézne ki:

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

A teszt paraméterezéséhez létrehoztunk egy modult bookingDialogTestCases , amely visszaadja a teszteset adatait. Minden elem tartalmaz egy tesztesetnevet, a kezdeti "BookingDetails" objektumot, a várt "BookingDetails" objektumot, valamint egy sztringtömböt a felhasználó által küldött kimondott szövegekkel és az egyes fordulókhoz tartozó párbeszédpanel várt válaszaival.

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

Miután létrehoztuk a tesztadatokat tartalmazó listát, újrabontást végezhetünk a teszten, hogy a listát egyedi tesztesetekké képezzük le.

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

Íme egy példa a DialogFlowUseCases Mocha Test Explorer tesztcsomagjának eredményeire a tesztcsomag végrehajtásakor:

A Mocks használata

A jelenleg nem tesztelt dolgokhoz használhat makettelemeket. Referenciaként ez a szint általában egység- és integrációs tesztelésnek tekinthető.

A lehető legtöbb elem szimulálása lehetővé teszi a tesztelt darab jobb elkülönítését. A modellelemekre jelölt elemek közé tartozik a tárolás, az adapter, a köztes szoftver, a tevékenységfolyamat, a csatornák és minden más, amely nem közvetlenül része a robotnak. Ez azt is jelentheti, hogy ideiglenesen eltávolít bizonyos szempontokat, például a köztes szoftvereket, amelyek nem vesznek részt a tesztelt robotban, hogy elkülönítse az egyes elemeket. Ha azonban teszteli a köztes szoftverét, érdemes lehet inkább a robotot kiképeztetni.

A mocking elemek több formát is igénybe vehetnek, az elemek egy másik ismert objektumra való lecserélésétől a hello világ minimális funkcionalitásának megvalósításáig. Ez azt is jelentheti, hogy eltávolítja az elemet, ha nincs rá szükség, vagy arra kényszeríti, hogy ne tegyen semmit.

A makettek lehetővé teszik a párbeszédpanelek függőségeinek konfigurálását, és biztosítjuk, hogy a teszt végrehajtása során ismert állapotban legyenek anélkül, hogy külső erőforrásokra, például adatbázisokra, nyelvi modellekre vagy más objektumokra kellene támaszkodnia.

Ahhoz, hogy a párbeszédpanel könnyebben tesztelhető és csökkenthető legyen a külső objektumoktól való függősége, előfordulhat, hogy be kell szúrnia a külső függőségeket a párbeszédpanel-konstruktorba.

Például ahelyett, hogy a következőben MainDialogkell példányt létrehozniaBookingDialog:

C#

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

JavaScript

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

Konstruktorparaméterként adunk át egy példányt BookingDialog :

C#

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

JavaScript

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

Ez lehetővé teszi, hogy lecseréljük a BookingDialog példányt egy szimulált objektumra, és egységteszteket írjunk anélkül MainDialog , hogy meghívnánk a tényleges BookingDialog osztályt.

C#

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

JavaScript

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

Mocking Dialogs

A fentiekben MainDialog leírtaknak megfelelően meghívja BookingDialog az objektum beszerzését BookingDetails . A következő modellpéldányokat BookingDialog implementáljuk és konfiguráljuk:

C#

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

Ebben a példában a Moq használatával hoztuk létre a makett párbeszédpanelt, valamint a Setup viselkedés konfigurálásához használt metódusokat.Returns

JavaScript

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

Ebben a példában a minta párbeszédpanelt úgy implementáljuk, hogy az alapul szolgáló párbeszédpanel logikáját megkerülő metódusból származtatjuk BookingDialog és felülírjuk beginDialog azt.

LUIS-eredmények szimulálása

Megjegyzés:

A Language Understanding (LUIS) 2025. október 1-jén megszűnik. 2023. április 1-től nem hozhat létre új LUIS-erőforrásokat. Az Azure AI Language részeként már elérhető a nyelvértés újabb verziója.

Az Azure AI Language egyik funkciója, a beszélgetési nyelv megértése (CLU) a LUIS frissített verziója. További információ a Bot Framework SDK nyelvfelismerési támogatásáról: Természetes nyelvfelismerés.

Egyszerű forgatókönyvekben a következő kódon keresztül valósíthatja meg a LUIS-eredmények szimulálásával:

C#

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

JavaScript

// 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);
...

A LUIS-eredmények összetettek lehetnek. Ha így van, egyszerűbb rögzíteni a kívánt eredményt egy JSON-fájlban, erőforrásként hozzáadni a projekthez, és deszerializálni egy LUIS-eredményben. Here's an example:

C#

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

JavaScript

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

További információk

• CoreBot-tesztminta (C#)
• CoreBot-tesztminta (JavaScript)
• Robottesztelés