bot-tester/dist/MessageService.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Promise = require("bluebird");
const config_1 = require("./config");
const OutgoingMessageComparator_1 = require("./OutgoingMessageComparator");
function expectedResponsesAreEmpty(expectedResponses) {
    return !expectedResponses || !expectedResponses.length || !expectedResponses[0].length;
}
/**
 * Handles sending messages to bot, intercepts the responses, and compares the response to the expected responses for the particular test
 * step
 */
class MessageService {
    constructor(bot, config) {
        this.bot = bot;
        this.applyOutgoingMessageListener();
        // in case messages aren't checked in the frist step(s)
        //tslint:disable
        this.botToUserMessageChecker = (msg) => { };
        //tslint:enable
        this.config = config;
    }
    /**
     * Sends message to bot and sets the expectations for the responses.
     *
     * @param message message to send to bot
     * @param expectedResponses expected responses
     */
    sendMessageToBot(message, expectedResponses, ignoreOrder = false) {
        const outgoingMessageComparator = new OutgoingMessageComparator_1.OutgoingMessageComparator(expectedResponses, ignoreOrder);
        const responsesFullyProcessedPromise = this.setBotToUserMessageChecker(expectedResponses, outgoingMessageComparator);
        const receiveMessagePromise = new Promise((res, rej) => {
            this.bot.receive(message, (e) => e ? rej(e) : res());
        });
        let promiseToReturn = expectedResponses && expectedResponses.length ? responsesFullyProcessedPromise : receiveMessagePromise;
        if (this.config.timeout !== config_1.NO_TIMEOUT) {
            promiseToReturn = promiseToReturn.timeout(this.config.timeout);
        }
        return promiseToReturn
            .catch(Promise.TimeoutError, (e) => {
            return Promise.reject(outgoingMessageComparator.getTimeoutErrorMessage());
        });
    }
    /**
     * Sets the current response expectation function for the message service. This allows the botToUserMessageChecker property to be
     * updated within a closure with the proper expectedResponses. The promise that is returned will only resolve when all responses have
     * been seen. Many tests will hang here and fail if an expected response is never received
     *
     * @param expectedResponses collection of expected responses for a particular step
     */
    setBotToUserMessageChecker(expectedResponses, outgoingMessageComparator) {
        return new Promise((res, rej) => {
            if (!outgoingMessageComparator.expectsAdditionalMessages()) {
                return res();
            }
            this.botToUserMessageChecker = (messages) => {
                if (!(messages instanceof Array)) {
                    messages = [messages];
                }
                messages.forEach((msg) => {
                    try {
                        outgoingMessageComparator.compareOutgoingMessageToExpectedResponses(msg);
                    }
                    catch (e) {
                        return rej(e);
                    }
                });
                if (!outgoingMessageComparator.expectsAdditionalMessages()) {
                    return res();
                }
            };
        });
    }
    /**
     * Inject middleware to intercept outgoing messages to check their content
     */
    applyOutgoingMessageListener() {
        this.bot.on('outgoing', (e) => {
            if (!(e instanceof Array)) {
                e = [e];
            }
            this.botToUserMessageChecker(e);
        });
    }
}
exports.MessageService = MessageService;
//# sourceMappingURL=MessageService.js.map