wa-chat-server
Version:
Watson Assistant powered chat server
380 lines (379 loc) • 18.4 kB
JavaScript
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RouteTest = void 0;
const Route_1 = require("../../class/Route/Route");
const WAChatServerConfigMock_1 = require("../mock/WAChatServerConfigMock");
const Logger_1 = require("../../class/Logger/Logger");
const Session_1 = require("../../class/Session/Session");
class RouteTest {
constructor() {
this.config = new WAChatServerConfigMock_1.WAChatServerConfigMock();
this.logger = new Logger_1.Logger(this.config);
}
doRoute(newPayload) {
return __awaiter(this, void 0, void 0, function* () {
const session = yield new Session_1.Session('ID').start();
session.data.assistants['MASTER'] = newPayload.result;
const route = new Route_1.Route(newPayload, session, this.config, this.logger);
if (route.refuseRoute === false) {
yield route.route();
}
return {
route: route,
session: session,
};
});
}
justRouteTest() {
return __awaiter(this, void 0, void 0, function* () {
it('justRoute', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({ target: 'TARGET', shared: {} });
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual(undefined);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
}));
});
}
routeWithMessageTest() {
return __awaiter(this, void 0, void 0, function* () {
it('routeWithMessage', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
},
input: {},
output: {
generic: [
{ response_type: 'text', text: 'Text co se posílá jako odpověď spolu s routingem.' }, //eslint-disable-line
],
},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({ target: 'TARGET', shared: {} });
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual(undefined);
expect(result.route.messagesBeforeRouting).toStrictEqual([
{ response_type: 'text', text: 'Text co se posílá jako odpověď spolu s routingem.' }, //eslint-disable-line
]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
}));
});
}
forcedIntentTest() {
return __awaiter(this, void 0, void 0, function* () {
it('forcedIntent', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
'route-intent': 'INTENT',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({
target: 'TARGET',
intent: 'INTENT',
shared: {},
});
expect(result.route.newPayload.result.context).toStrictEqual({
'route-intent': null,
'incoming_route-origin': 'MASTER',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual([
{ confidence: 1, intent: 'INTENT' },
]);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-intent': null,
});
}));
});
}
forcedUtteranceTest() {
return __awaiter(this, void 0, void 0, function* () {
it('forcedUtterance', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
'route-utterance': 'UTTERANCE',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({
target: 'TARGET',
utterance: 'UTTERANCE',
shared: {},
});
expect(result.route.newPayload.result.context).toStrictEqual({
'route-utterance': null,
'incoming_route-origin': 'MASTER',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual(undefined);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-utterance': null,
});
}));
});
}
forcedParamsTest() {
return __awaiter(this, void 0, void 0, function* () {
it('forcedParams', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
'route-params-PARAM1': 'VALUE1',
'route-params-PARAM2': 'VALUE2',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({
target: 'TARGET',
params: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
shared: {},
});
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-params-PARAM1': null,
'route-params-PARAM2': null,
});
expect(result.route.newPayload.result.input.intents).toStrictEqual(undefined);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-params-PARAM1': null,
'route-params-PARAM2': null,
});
}));
});
}
sharedParamsTest() {
return __awaiter(this, void 0, void 0, function* () {
it('sharedParams', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({
target: 'TARGET',
shared: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
});
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual(undefined);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({
shared: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
runningAssistant: 'TARGET',
});
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
});
}));
});
}
allTest() {
return __awaiter(this, void 0, void 0, function* () {
it('all', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
'route-utterance': 'UTTERANCE',
'route-intent': 'INTENT',
'route-params-PARAM1': 'VALUE1',
'route-params-PARAM2': 'VALUE2',
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
},
input: {},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({
target: 'TARGET',
intent: 'INTENT',
utterance: 'UTTERANCE',
params: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
shared: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
});
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-intent': null,
'route-utterance': null,
'route-params-PARAM1': null,
'route-params-PARAM2': null,
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual([
{ confidence: 1, intent: 'INTENT' },
]);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({
shared: { PARAM1: 'VALUE1', PARAM2: 'VALUE2' },
runningAssistant: 'TARGET',
});
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
'route-intent': null,
'route-utterance': null,
'route-params-PARAM1': null,
'route-params-PARAM2': null,
'shared-PARAM1': 'VALUE1',
'shared-PARAM2': 'VALUE2',
});
}));
});
}
disambFirstRoundTest() {
return __awaiter(this, void 0, void 0, function* () {
it('disamb1', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(4);
const newPayloadMOCK = {
result: {
context: {},
input: {},
output: {
generic: [{ response_type: 'suggestion', text: 'DISAMB_TEXT' }], //eslint-disable-line
},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(true);
expect(result.route.routeContext).toStrictEqual({ target: null });
expect(result.session.runningAssistant).toStrictEqual('MASTER');
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({});
}));
});
}
disambSecondRoundTest() {
return __awaiter(this, void 0, void 0, function* () {
it('disamb2', () => __awaiter(this, void 0, void 0, function* () {
expect.assertions(8);
const newPayloadMOCK = {
result: {
context: {
'route-target': 'TARGET',
},
input: {
suggestion_id: 'd:91feada3-d457-4b81-8b33-fce1b5c80aff', //eslint-disable-line
text: 'DISAMB_TEXT',
intents: [{ intent: 'disamb1', confidence: 1 }],
entities: [],
message_type: 'text', //eslint-disable-line
options: { debug: true, return_context: true }, //eslint-disable-line
},
},
};
const result = yield this.doRoute(newPayloadMOCK);
expect(result.route.refuseRoute).toStrictEqual(false);
expect(result.route.routeContext).toStrictEqual({ target: 'TARGET', shared: {} });
expect(result.route.newPayload.result.context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
expect(result.route.newPayload.result.input.intents).toStrictEqual([
{ confidence: 1, intent: 'disamb1' },
]);
expect(result.route.messagesBeforeRouting).toStrictEqual([]);
expect(result.session.runningAssistant).toStrictEqual('TARGET');
expect(result.session.data.general).toStrictEqual({ shared: {}, runningAssistant: 'TARGET' });
expect(result.session.data.assistants['MASTER'].context).toStrictEqual({
'incoming_route-origin': 'MASTER',
});
}));
});
}
test() {
return __awaiter(this, void 0, void 0, function* () {
this.justRouteTest();
this.routeWithMessageTest();
this.forcedIntentTest();
this.forcedUtteranceTest();
this.forcedParamsTest();
this.sharedParamsTest();
this.allTest();
this.disambFirstRoundTest();
this.disambSecondRoundTest();
});
}
}
exports.RouteTest = RouteTest;
new RouteTest().test();