bot-tester/dist/BotTester.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Promise = require("bluebird");
const botbuilder_1 = require("botbuilder");
const config_1 = require("./config");
const ExpectedMessage_1 = require("./ExpectedMessage");
const MessageService_1 = require("./MessageService");
const SessionService_1 = require("./SessionService");
//tslint:enable
/**
 * Test builder and runner for botbuilder bots
 */
class BotTester {
    //tslint:disable
    /**
     *
     * @param bot bot that will be tested against
     * @param options (optional) options to pass to bot. Sets the default address and test timeout
     */
    //tslint:enable
    constructor(bot, options = config_1.config) {
        const defaultAndInputOptionMix = Object.assign({}, config_1.config, options);
        this.bot = bot;
        this.defaultAddress = defaultAndInputOptionMix.defaultAddress;
        this.messageService = new MessageService_1.MessageService(bot, defaultAndInputOptionMix);
        this.sessionLoader = new SessionService_1.SessionService(bot);
        this.testSteps = [];
    }
    /**
     * executes each test step serially
     */
    //tslint:disable
    runTest() {
        //tslint:enable
        return Promise.mapSeries(this.testSteps, (fn) => fn());
    }
    /**
     * loads a session associated with an address and passes it to a user defined function
     * @param sessionCheckerFunction function passed in to inspect message
     * @param address (Optional) address of the session to load. Defaults to bot's default address if not defined
     */
    checkSession(sessionCheckerFunction, address) {
        const runSessionChecker = () => this.sessionLoader.getSession(address || this.defaultAddress)
            .then(sessionCheckerFunction);
        this.testSteps.push(runSessionChecker);
        return this;
    }
    /**
     * sends a message to a bot and compares bot responses against expectedResponsess. Expected responses can be a variable number of args,
     * each of which can be a single expected response of any PossibleExpectedMessageType or a collection of PossibleExpectedMessageType
     * that mocks a randomly selected response by the bot
     * @param msg message to send to bot
     * @param expectedResponses (Optional) responses the bot-tester framework checks against
     */
    sendMessageToBot(msg, 
        // currently only supports string RegExp IMessage
        ...expectedResponses) {
        const message = this.convertToIMessage(msg);
        // possible that expected responses may be undefined. Remove them
        expectedResponses = expectedResponses.filter((expectedResponse) => expectedResponse);
        return this.sendMessageToBotInternal(message, expectedResponses);
    }
    sendMessageToBotIgnoringResponseOrder(msg, 
        // currently only supports string RegExp IMessage
        ...expectedResponses) {
        const message = this.convertToIMessage(msg);
        // possible that expected responses may be undefined. Remove them
        expectedResponses = expectedResponses.filter((expectedResponse) => expectedResponse);
        return this.sendMessageToBotInternal(message, expectedResponses, true);
    }
    /**
     * sends a message to the bot. This should be used whenever session.save() is used without sending a reply to the user. This exists due
     * to a limitation in the current implementation of the botbuilder framework
     *
     * @param msg message to send to bot
     */
    sendMessageToBotAndExpectSaveWithNoResponse(msg) {
        const message = this.convertToIMessage(msg);
        return this.sendMessageToBotInternal(message, [this.sessionLoader.getInternalSaveMessage(message.address)]);
    }
    /**
     * Works exactly like Promise's .then function, except that the return value is not passed as an arg to the next function (even if its
     * another .then)
     * @param fn some function to run
     */
    //tslint:disable
    then(fn) {
        //tslint:enable
        this.testSteps.push(() => Promise.method(fn)());
        return this;
    }
    /**
     * Waits for the given delay between test steps.
     * @param delayInMiliseconds time to wait in milliseconds
     */
    wait(delayInMilliseconds) {
        this.testSteps.push(() => Promise.delay(delayInMilliseconds));
        return this;
    }
    convertToIMessage(msg) {
        if (typeof (msg) === 'string') {
            return new botbuilder_1.Message()
                .text(msg)
                .address(this.defaultAddress)
                .toMessage();
        }
        return msg;
    }
    /**
     * Packages the expected messages into an ExpectedMessage collection to be handed off to the MessageService's sendMessageToBot function
     * @param message message to be sent to bot
     * @param expectedResponses expected responses
     */
    sendMessageToBotInternal(message, 
        // currently only supports string RegExp IMessage
        expectedResponses, ignoreOrder = false) {
        let expectedMessages = [];
        if (!expectedResponses) {
            expectedMessages = [];
        }
        else if (!(expectedResponses instanceof Array)) {
            expectedMessages = [new ExpectedMessage_1.ExpectedMessage(expectedResponses)];
        }
        else if (expectedResponses instanceof Array) {
            if (expectedResponses.length > 0) {
                expectedMessages = expectedResponses
                    .map((currentExpectedResponseCollection) => new ExpectedMessage_1.ExpectedMessage(currentExpectedResponseCollection));
                // tslint:enable
            }
        }
        this.testSteps.push(() => this.messageService.sendMessageToBot(message, expectedMessages, ignoreOrder));
        return this;
    }
}
exports.BotTester = BotTester;
//# sourceMappingURL=BotTester.js.map