bot-tester/dist/ExpectedMessage.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const IExpectation_1 = require("./assertionLibraries/IExpectation");
var ExpectedMessageType;
(function (ExpectedMessageType) {
    ExpectedMessageType[ExpectedMessageType["String"] = 0] = "String";
    ExpectedMessageType[ExpectedMessageType["IMessage"] = 1] = "IMessage";
    ExpectedMessageType[ExpectedMessageType["Regex"] = 2] = "Regex";
})(ExpectedMessageType = exports.ExpectedMessageType || (exports.ExpectedMessageType = {}));
function getExpectedMessageType(expectedResponseCollection) {
    const firstElt = expectedResponseCollection[0];
    if (typeof firstElt === 'string') {
        return ExpectedMessageType.String;
    }
    else if (firstElt.constructor.name === 'RegExp') {
        return ExpectedMessageType.Regex;
    }
    else {
        return ExpectedMessageType.IMessage;
    }
}
/**
 * Class that wraps expectedResponseCollections for comparison against an outgoing message. One instance of ExpectedMessage represents one
 * response from the bot.
 */
class ExpectedMessage {
    constructor(expectedResponseCollection) {
        if (!(expectedResponseCollection instanceof Array)) {
            this.expectedResponseCollection = [expectedResponseCollection];
        }
        else {
            this.expectedResponseCollection = expectedResponseCollection;
        }
        IExpectation_1.expect(this.expectedResponseCollection, 'expected response collections cannot be empty').notToBeEmpty();
    }
    /**
     * routes the outgoingMessage to the proper comparison method based on the expectedResponseCollection. This switch based method exists
     * due to typescript's lack of polymorphism support.
     *
     * @param outgoingMessage outgoing message that is being compared
     */
    checkForMessageMatch(outgoingMessage) {
        switch (getExpectedMessageType(this.expectedResponseCollection)) {
            case ExpectedMessageType.String:
                this.checkMessageTextForExactStringMatch(outgoingMessage, this.expectedResponseCollection);
                break;
            case ExpectedMessageType.Regex:
                this.checkMessageTextForRegex(outgoingMessage);
                break;
            case ExpectedMessageType.IMessage:
                // doing this check will highlight if the diff in text instead of a large IMessage diff
                this.deepMessageMatchCheck(outgoingMessage);
                break;
            default:
                IExpectation_1.expect(outgoingMessage.type).toEqual('save');
        }
    }
    toString() {
        return JSON.stringify(this.expectedResponseCollection, null, 2);
    }
    /**
     * Asserts that outgoingMessage.text is within the expectedResponseStrings collection
     *
     * @param outgoingMessage outgoing message being compared
     * @param expectedResponseStrings collection of possible string values for comparison
     */
    checkMessageTextForExactStringMatch(outgoingMessage, expectedResponseStrings) {
        const outgoingText = outgoingMessage.text;
        const errorStringExpectedResponseText = expectedResponseStrings.length > 1 ? `one of ${expectedResponseStrings}` : expectedResponseStrings[0];
        const errorString = `Bot should have responded with '${errorStringExpectedResponseText}', but was '${outgoingText}`;
        IExpectation_1.expect(expectedResponseStrings, errorString).toInclude(outgoingText);
    }
    /**
     * Assumes the expectedResponseCollection are regexs. Asserts that outgoingMessage.text matches at least of the regexs in
     * expectedResponseCollection
     *
     * @param outgoingMessage outgoing message being compared
     */
    checkMessageTextForRegex(outgoingMessage) {
        const text = outgoingMessage.text;
        const regexCollection = this.expectedResponseCollection;
        IExpectation_1.expect(regexCollection.some((regex) => regex.test(text)), `${text} did not match any regex in ${regexCollection}`).toBeTrue();
    }
    /**
     * Assumes the expectedResponseCollection is an IMessage[]. Asserts that at least one IMessage in expectedResponseCollection is fully
     * contained within the outgoingMessage (i.e. the outgoingMessage  {type: 'message', text:'hello'}) would be matched successfully
     * against {type: 'message', text: 'hello', user: { id: user1 }} because the outgoing message is contained within the response. It would
     * not successfulyl be matched against {text: 'hello', user: { id: user1 }} because the expected response is missing { type: 'message' }
     * @param outgoingMessage outgoing message being compared
     */
    deepMessageMatchCheck(outgoingMessage) {
        const expectedResponseCollectionAsIMessage = this.expectedResponseCollection;
        const expectedResponseStrings = 
        // get all possible responses as strings. It is possible that the expected responses have no text, so filter out those values
        expectedResponseCollectionAsIMessage
            .map((expectedResponse) => expectedResponse.text)
            .filter((text) => text);
        if (expectedResponseStrings.length) {
            // doing this check will highlight if the diff in text instead of a large IMessage diff
            this.checkMessageTextForExactStringMatch(outgoingMessage, expectedResponseStrings);
        }
        IExpectation_1.expect(expectedResponseCollectionAsIMessage).toDeeplyInclude(outgoingMessage);
    }
}
exports.ExpectedMessage = ExpectedMessage;
//# sourceMappingURL=ExpectedMessage.js.map