wa-chat-server/lib/test/class/LoggerDriverLogDNATest.js

Watson Assistant powered chat server

"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.LoggerDriverLogDNATest = void 0;
const LoggerDriverLogDNA_1 = require("../../class/Logger/LoggerDriverLogDNA");
const WAChatServerConfigMock_1 = require("../mock/WAChatServerConfigMock");
class LoggerDriverLogDNATest {
    getConfig(logLevel) {
        return Object.assign(new WAChatServerConfigMock_1.WAChatServerConfigMock(), {
            logdna_key: 'KEY', // eslint-disable-line @typescript-eslint/camelcase
            logdna_url: 'http://eu.eu', // eslint-disable-line @typescript-eslint/camelcase
            logdna_app: 'APP', // eslint-disable-line @typescript-eslint/camelcase
            logdna_app_hostname: 'HOSTNAME', // eslint-disable-line @typescript-eslint/camelcase
            logdna_log_level: logLevel, // eslint-disable-line @typescript-eslint/camelcase
        });
    }
    getDriver(level, msg, params) {
        const logDNAMock = {
            createLogger: (key, options) => {
                expect(key).toStrictEqual('KEY');
                expect(options).toStrictEqual({
                    url: 'http://eu.eu', // eslint-disable-line @typescript-eslint/camelcase
                    app: 'APP',
                    hostname: 'HOSTNAME',
                });
                return {
                    log(message, options) {
                        expect(message).toStrictEqual(msg);
                        expect(options).toStrictEqual({
                            level,
                            meta: params,
                        });
                    },
                };
            },
        };
        return new LoggerDriverLogDNA_1.LoggerDriverLogDNA(this.getConfig(level), logDNAMock);
    }
    constructorTest() {
        return __awaiter(this, void 0, void 0, function* () {
            it('constructor', () => {
                expect.assertions(1);
                try {
                    new LoggerDriverLogDNA_1.LoggerDriverLogDNA(this.getConfig('debug'));
                    expect(true).toStrictEqual(true);
                }
                catch (e) {
                    console.error(e.toString());
                }
            });
        });
    }
    logTest(level) {
        return __awaiter(this, void 0, void 0, function* () {
            it(`log-${level}`, () => __awaiter(this, void 0, void 0, function* () {
                expect.assertions(4);
                const msg = 'MSG';
                const params = [{ a: 'A' }, { b: 'B' }];
                const driver = this.getDriver(level, msg, { params });
                yield driver.log(level, msg, params);
            }));
        });
    }
    logJustOneParamTest(level) {
        return __awaiter(this, void 0, void 0, function* () {
            it(`log-just_one_param`, () => __awaiter(this, void 0, void 0, function* () {
                expect.assertions(4);
                const msg = 'MSG';
                const params = [{ a: 'A' }];
                const driver = this.getDriver(level, msg, params[0]);
                yield driver.log(level, msg, params);
            }));
        });
    }
    ignoredCallTest(callLevel, logLevel) {
        return __awaiter(this, void 0, void 0, function* () {
            it(`log-ignored_${callLevel}_for_level_${logLevel}`, () => __awaiter(this, void 0, void 0, function* () {
                expect.assertions(2);
                const msg = 'MSG';
                const params = [{ a: 'A' }];
                const driver = this.getDriver(logLevel, msg, params[0]);
                yield driver.log(callLevel, msg, params);
            }));
        });
    }
    ignoredCallWithDefaultLevelTest(callLevel) {
        return __awaiter(this, void 0, void 0, function* () {
            it(`log-ignored_${callLevel}_for_default_level`, () => __awaiter(this, void 0, void 0, function* () {
                expect.assertions(2);
                const msg = 'MSG';
                const params = [{ a: 'A' }];
                const driver = this.getDriver(null, msg, params[0]);
                yield driver.log(callLevel, msg, params);
            }));
        });
    }
    invalidLogLevelTest() {
        return __awaiter(this, void 0, void 0, function* () {
            it('invalid_log_level', () => __awaiter(this, void 0, void 0, function* () {
                expect.assertions(1);
                try {
                    this.getDriver('INVALID', 'MSG', [{ a: 'A' }]);
                }
                catch (e) {
                    expect(e).toStrictEqual(new Error("Log level 'INVALID' is not valid!"));
                }
            }));
        });
    }
    test() {
        return __awaiter(this, void 0, void 0, function* () {
            this.constructorTest();
            ['debug', 'info', 'warn', 'error'].forEach((level) => {
                this.logTest(level);
            });
            this.logJustOneParamTest('debug');
            this.ignoredCallTest('debug', 'info');
            this.ignoredCallTest('info', 'warn');
            this.ignoredCallTest('warn', 'error');
            this.ignoredCallWithDefaultLevelTest('warn');
            this.invalidLogLevelTest();
        });
    }
}
exports.LoggerDriverLogDNATest = LoggerDriverLogDNATest;
new LoggerDriverLogDNATest().test();