slf4ts-api/build/packages/slf4ts-api/test/slf4ts/LoggerFactoryTest.js

Simple logging facade for nodejs

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
require("source-map-support/register");
const chai = require("chai");
const mocha_typescript_1 = require("mocha-typescript");
const path = require("path");
const LoggerConfiguration_1 = require("../../lib/slf4ts/LoggerConfiguration");
const LoggerFactory_1 = require("../../lib/slf4ts/LoggerFactory");
const expect = chai.expect;
const fail = chai.assert.fail;
const nodeModuleExtraPath = path.join(__dirname, '..', '..', 'example-node-modules');
process.env.NODE_PATH = nodeModuleExtraPath;
process.env.LOGGER_BINDING_ADDITIONAL_PATH = nodeModuleExtraPath;
require('module').Module._initPaths();
let LoggerFactoryTest = class LoggerFactoryTest {
    before() {
        LoggerConfiguration_1.LoggerConfiguration.reset();
        LoggerFactory_1.LoggerFactory.reset(true);
    }
    checkRootLogger() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger();
        const loggerImpl = logger.getImpl();
        logger.setMetadata({ mode: 'Test' });
        expect(loggerImpl).to.exist;
        logger.info('Test Message')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(1);
        expect(loggerImpl.calls[0][0]).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(loggerImpl.calls[0][1]).to.equal('');
        expect(loggerImpl.calls[0][2]).to.equal('');
        expect(loggerImpl.calls[0][3]).to.equal('Test Message');
        expect(loggerImpl.calls[0][4]).to.deep.equal({ mode: 'Test' });
    }
    checkRootLogLevel() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger();
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
    }
    checkSetRootLogLevel() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger();
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.DEBUG);
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.DEBUG);
    }
    checkGetImplementation() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger();
        expect(logger.getImplementation()).to.equal(console);
    }
    checkGetNamedLogger() {
        const group = 'group1';
        const name = 'name1';
        expect(LoggerFactory_1.LoggerFactory.getLogger() === LoggerFactory_1.LoggerFactory.getLogger()).to.be.true;
        expect(LoggerFactory_1.LoggerFactory.getLogger(group) === LoggerFactory_1.LoggerFactory.getLogger(group)).to.be.true;
        expect(LoggerFactory_1.LoggerFactory.getLogger(group, name) === LoggerFactory_1.LoggerFactory.getLogger(group, name)).to.be.true;
        expect(LoggerFactory_1.LoggerFactory.getLogger(group) !== LoggerFactory_1.LoggerFactory.getLogger(group, name)).to.be.true;
        expect(LoggerFactory_1.LoggerFactory.getLogger() !== LoggerFactory_1.LoggerFactory.getLogger(group)).to.be.true;
        expect(LoggerFactory_1.LoggerFactory.getLogger() !== LoggerFactory_1.LoggerFactory.getLogger(group, name)).to.be.true;
    }
    checkSetLogLevel() {
        const group = 'group1';
        const name1 = 'name1';
        const name2 = 'name2';
        const rootLogger = LoggerFactory_1.LoggerFactory.getLogger();
        const loggerImpl = rootLogger.getImpl();
        const groupLogger = LoggerFactory_1.LoggerFactory.getLogger(group);
        const namedLogger1 = LoggerFactory_1.LoggerFactory.getLogger(group, name1);
        const namedLogger2 = LoggerFactory_1.LoggerFactory.getLogger(group, name2);
        expect(rootLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(groupLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(namedLogger1.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(namedLogger2.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.DEBUG, group, name1);
        expect(loggerImpl.setLogLevelCalls).to.have.length(1);
        expect(loggerImpl.setLogLevelCalls[0][0]).to.deep.equal(LoggerConfiguration_1.LogLevel.DEBUG);
        expect(loggerImpl.setLogLevelCalls[0][1]).to.equal(group);
        expect(loggerImpl.setLogLevelCalls[0][2]).to.equal(name1);
        expect(rootLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(groupLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(namedLogger1.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.DEBUG);
        expect(namedLogger2.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.TRACE, group);
        expect(loggerImpl.setLogLevelCalls).to.have.length(4);
        expect(loggerImpl.setLogLevelCalls[1][0]).to.deep.equal(LoggerConfiguration_1.LogLevel.TRACE);
        expect(loggerImpl.setLogLevelCalls[1][1]).to.equal(group);
        expect(loggerImpl.setLogLevelCalls[1][2]).to.equal('');
        expect(loggerImpl.setLogLevelCalls[2][0]).to.deep.equal(LoggerConfiguration_1.LogLevel.TRACE);
        expect(loggerImpl.setLogLevelCalls[2][1]).to.equal(group);
        expect(loggerImpl.setLogLevelCalls[2][2]).to.equal(name1);
        expect(loggerImpl.setLogLevelCalls[3][0]).to.deep.equal(LoggerConfiguration_1.LogLevel.TRACE);
        expect(loggerImpl.setLogLevelCalls[3][1]).to.equal(group);
        expect(loggerImpl.setLogLevelCalls[3][2]).to.equal(name2);
        expect(rootLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(groupLogger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.TRACE);
        expect(namedLogger1.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.TRACE);
        expect(namedLogger2.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.TRACE);
    }
    checkCorrectLogLevelInvocations() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger('group1', 'name1');
        const loggerImpl = logger.getImpl();
        logger.setMetadata({ mode: 'Test' });
        expect(loggerImpl).to.exist;
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.INFO);
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        logger.info('Test Message 1')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(1);
        expect(loggerImpl.calls[0][0]).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(loggerImpl.calls[0][1]).to.equal('group1');
        expect(loggerImpl.calls[0][2]).to.equal('name1');
        expect(loggerImpl.calls[0][3]).to.equal('Test Message 1');
        expect(loggerImpl.calls[0][4]).to.deep.equal({ mode: 'Test' });
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.WARN);
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.WARN);
        logger.info('Test Message 2')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(1);
        LoggerConfiguration_1.LoggerConfiguration.setLogLevel(LoggerConfiguration_1.LogLevel.DEBUG);
        expect(logger.getLogLevel()).to.equal(LoggerConfiguration_1.LogLevel.DEBUG);
        logger.info('Test Message 3')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(2);
        expect(loggerImpl.calls[1][0]).to.equal(LoggerConfiguration_1.LogLevel.INFO);
        expect(loggerImpl.calls[1][1]).to.equal('group1');
        expect(loggerImpl.calls[1][2]).to.equal('name1');
        expect(loggerImpl.calls[1][3]).to.equal('Test Message 3');
        expect(loggerImpl.calls[1][4]).to.deep.equal({ mode: 'Test' });
    }
    checkMetadataArguments() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger('group1', 'name1');
        const loggerImpl = logger.getImpl();
        logger.info('Test Message 1')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(1);
        expect(loggerImpl.calls[0]).to.have.length(5);
        expect(loggerImpl.calls[0][4]).to.not.exist;
        logger.info('Test Message 2', { arg1: 'value1' })
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(2);
        expect(loggerImpl.calls[1]).to.have.length(6);
        expect(loggerImpl.calls[1][4]).to.deep.equal({ arg1: 'value1' });
        expect(loggerImpl.calls[1][5]).to.not.exist;
        logger.setMetadata({ mode: 'Test', version: '1.0.0' });
        logger.info('Test Message 3')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(3);
        expect(loggerImpl.calls[2]).to.have.length(5);
        expect(loggerImpl.calls[2][4]).to.deep.equal({ mode: 'Test', version: '1.0.0' });
        logger.info('Test Message 4', { arg1: 'value1' })
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(4);
        expect(loggerImpl.calls[3]).to.have.length(6);
        expect(loggerImpl.calls[3][4]).to.deep.equal({ arg1: 'value1' });
        expect(loggerImpl.calls[3][5]).to.deep.equal({ mode: 'Test', version: '1.0.0' });
        const error = new Error('Test');
        logger.info('Test Message 5', { arg1: 'value1' }, error)
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(5);
        expect(loggerImpl.calls[4]).to.have.length(7);
        expect(loggerImpl.calls[4][4]).to.deep.equal({ arg1: 'value1' });
        expect(loggerImpl.calls[4][5]).to.equal(error);
        expect(loggerImpl.calls[4][6]).to.deep.equal({ mode: 'Test', version: '1.0.0' });
        logger.info('Test Message 6', null, error)
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(6);
        expect(loggerImpl.calls[5]).to.have.length(7);
        expect(loggerImpl.calls[5][4]).to.be.null;
        expect(loggerImpl.calls[5][5]).to.equal(error);
        expect(loggerImpl.calls[5][6]).to.deep.equal({ mode: 'Test', version: '1.0.0' });
        logger.info('Test Message 7', error)
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(7);
        expect(loggerImpl.calls[6]).to.have.length(6);
        expect(loggerImpl.calls[6][4]).to.equal(error);
        expect(loggerImpl.calls[6][5]).to.deep.equal({ mode: 'Test', version: '1.0.0' });
    }
    checkSetConfig() {
        const group = 'group1';
        const name1 = 'name1';
        const name2 = 'name2';
        const rootLogger = LoggerFactory_1.LoggerFactory.getLogger();
        const loggerImpl = rootLogger.getImpl();
        LoggerFactory_1.LoggerFactory.getLogger(group);
        LoggerFactory_1.LoggerFactory.getLogger(group, name1);
        LoggerFactory_1.LoggerFactory.getLogger(group, name2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.not.exist;
        expect(loggerImpl.setConfigCalls).to.have.length(4);
        loggerImpl.setConfigCalls.splice(0, 4);
        const config1 = { key: 'value1' };
        const config2 = { key: 'value2' };
        const config3 = { key: 'value3' };
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.equal(config1);
        expect(loggerImpl.setConfigCalls).to.have.length(4);
        expect(loggerImpl.setConfigCalls[0][0]).to.deep.equal(config1);
        expect(loggerImpl.setConfigCalls[0][1]).to.equal('');
        expect(loggerImpl.setConfigCalls[0][2]).to.equal('');
        expect(loggerImpl.setConfigCalls[1][0]).to.deep.equal(config1);
        expect(loggerImpl.setConfigCalls[1][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[1][2]).to.equal('');
        expect(loggerImpl.setConfigCalls[2][0]).to.deep.equal(config1);
        expect(loggerImpl.setConfigCalls[2][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[2][2]).to.equal(name1);
        expect(loggerImpl.setConfigCalls[3][0]).to.deep.equal(config1);
        expect(loggerImpl.setConfigCalls[3][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[3][2]).to.equal(name2);
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config2, group);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.equal(config2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.equal(config2);
        expect(loggerImpl.setConfigCalls).to.have.length(7);
        expect(loggerImpl.setConfigCalls[4][0]).to.deep.equal(config2);
        expect(loggerImpl.setConfigCalls[4][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[4][2]).to.equal('');
        expect(loggerImpl.setConfigCalls[5][0]).to.deep.equal(config2);
        expect(loggerImpl.setConfigCalls[5][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[5][2]).to.equal(name1);
        expect(loggerImpl.setConfigCalls[6][0]).to.deep.equal(config2);
        expect(loggerImpl.setConfigCalls[6][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[6][2]).to.equal(name2);
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config3, group, name1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.equal(config2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config3);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.equal(config2);
        expect(loggerImpl.setConfigCalls).to.have.length(8);
        expect(loggerImpl.setConfigCalls[7][0]).to.deep.equal(config3);
        expect(loggerImpl.setConfigCalls[7][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[7][2]).to.equal(name1);
    }
    checkConfigInheritance() {
        const group = 'group1';
        const name1 = 'name1';
        const name2 = 'name2';
        const rootLogger = LoggerFactory_1.LoggerFactory.getLogger();
        const loggerImpl = rootLogger.getImpl();
        LoggerFactory_1.LoggerFactory.getLogger(group);
        LoggerFactory_1.LoggerFactory.getLogger(group, name1);
        LoggerFactory_1.LoggerFactory.getLogger(group, name2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.not.exist;
        loggerImpl.setConfigCalls.splice(0, 4);
        const config1 = { key: 'value1' };
        const config2 = { key: 'value2' };
        const config3 = { key: 'value3' };
        expect(loggerImpl.setConfigCalls).to.have.length(0);
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config1, group, name1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.not.exist;
        expect(loggerImpl.setConfigCalls).to.have.length(1);
        expect(loggerImpl.setConfigCalls[0][0]).to.deep.equal(config1);
        expect(loggerImpl.setConfigCalls[0][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[0][2]).to.equal(name1);
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config2, group);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.not.exist;
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.equal(config2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.equal(config2);
        expect(loggerImpl.setConfigCalls).to.have.length(3);
        expect(loggerImpl.setConfigCalls[1][0]).to.deep.equal(config2);
        expect(loggerImpl.setConfigCalls[1][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[1][2]).to.equal('');
        expect(loggerImpl.setConfigCalls[2][0]).to.deep.equal(config2);
        expect(loggerImpl.setConfigCalls[2][1]).to.equal(group);
        expect(loggerImpl.setConfigCalls[2][2]).to.equal(name2);
        LoggerConfiguration_1.LoggerConfiguration.setConfig(config3);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig()).to.equal(config3);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group)).to.equal(config2);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name1)).to.equal(config1);
        expect(LoggerConfiguration_1.LoggerConfiguration.getConfig(group, name2)).to.equal(config2);
        expect(loggerImpl.setConfigCalls).to.have.length(4);
        expect(loggerImpl.setConfigCalls[3][0]).to.deep.equal(config3);
        expect(loggerImpl.setConfigCalls[3][1]).to.equal('');
        expect(loggerImpl.setConfigCalls[3][2]).to.equal('');
    }
    checkSetMetadataOnLoggerFactory() {
        const logger = LoggerFactory_1.LoggerFactory.getLogger();
        const loggerImpl = logger.getImpl();
        logger.info('Test Message 1')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(1);
        expect(loggerImpl.calls[0]).to.have.length(5);
        expect(loggerImpl.calls[0][4]).to.not.exist;
        LoggerFactory_1.LoggerFactory.setMetadata({ arg1: 'value1' });
        logger.info('Test Message 2')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(2);
        expect(loggerImpl.calls[1]).to.have.length(5);
        expect(loggerImpl.calls[1][4]).to.deep.equal({ arg1: 'value1' });
        LoggerFactory_1.LoggerFactory.setMetadata({ arg1: 'value2', arg2: 'value3' });
        logger.info('Test Message 3')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(3);
        expect(loggerImpl.calls[2]).to.have.length(5);
        expect(loggerImpl.calls[2][4]).to.deep.equal({ arg1: 'value2', arg2: 'value3' });
        logger.setMetadata({ arg1: 'value4' });
        logger.info('Test Message 4')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(4);
        expect(loggerImpl.calls[3]).to.have.length(5);
        expect(loggerImpl.calls[3][4]).to.deep.equal({ arg1: 'value4' });
        LoggerFactory_1.LoggerFactory.setMetadata({ arg1: 'value5', arg2: 'value6' });
        logger.info('Test Message 5')
            .catch(fail);
        expect(loggerImpl.calls).to.have.length(5);
        expect(loggerImpl.calls[4]).to.have.length(5);
        expect(loggerImpl.calls[4][4]).to.deep.equal({ arg1: 'value4' });
    }
    checkSetMetadata() {
        LoggerFactory_1.LoggerFactory.setMetadata({});
        const group = 'group1';
        const name1 = 'name1';
        const name2 = 'name2';
        const rootLogger = LoggerFactory_1.LoggerFactory.getLogger();
        const groupLogger = LoggerFactory_1.LoggerFactory.getLogger(group);
        const namedLogger1 = LoggerFactory_1.LoggerFactory.getLogger(group, name1);
        const namedLogger2 = LoggerFactory_1.LoggerFactory.getLogger(group, name2);
        const loggerImpl = rootLogger.getImpl();
        const defaultLogger = rootLogger;
        const defaultGroupLogger = groupLogger;
        const defaultNamedLogger1 = namedLogger1;
        const defaultNamedLogger2 = namedLogger2;
        const rootMetadata = {
            key1: 'value1'
        };
        const namedLogger1Metadata = {
            key2: 'value2'
        };
        const groupLoggerMetadata = {
            key3: 'value3'
        };
        expect(defaultLogger.getMetadata()).to.deep.equal({});
        expect(defaultGroupLogger.getMetadata()).to.deep.equal({});
        expect(defaultNamedLogger1.getMetadata()).to.deep.equal({});
        expect(defaultNamedLogger2.getMetadata()).to.deep.equal({});
        rootLogger.setMetadata(rootMetadata);
        expect(loggerImpl.setMetadataCalls).to.have.length(1);
        expect(loggerImpl.setMetadataCalls[0][0]).to.deep.equal(rootMetadata);
        expect(loggerImpl.setMetadataCalls[0][1]).to.equal('');
        expect(loggerImpl.setMetadataCalls[0][2]).to.equal('');
        expect(defaultLogger.getMetadata()).to.deep.equal(rootMetadata);
        expect(defaultGroupLogger.getMetadata()).to.deep.equal({});
        expect(defaultNamedLogger1.getMetadata()).to.deep.equal({});
        expect(defaultNamedLogger2.getMetadata()).to.deep.equal({});
        defaultNamedLogger1.setMetadata(namedLogger1Metadata);
        expect(loggerImpl.setMetadataCalls).to.have.length(2);
        expect(loggerImpl.setMetadataCalls[1][0]).to.deep.equal(namedLogger1Metadata);
        expect(loggerImpl.setMetadataCalls[1][1]).to.equal(group);
        expect(loggerImpl.setMetadataCalls[1][2]).to.equal(name1);
        expect(defaultLogger.getMetadata()).to.deep.equal(rootMetadata);
        expect(defaultGroupLogger.getMetadata()).to.deep.equal({});
        expect(defaultNamedLogger1.getMetadata()).to.deep.equal(namedLogger1Metadata);
        expect(defaultNamedLogger2.getMetadata()).to.deep.equal({});
        defaultGroupLogger.setMetadata(groupLoggerMetadata);
        expect(loggerImpl.setMetadataCalls).to.have.length(3);
        expect(loggerImpl.setMetadataCalls[2][0]).to.deep.equal(groupLoggerMetadata);
        expect(loggerImpl.setMetadataCalls[2][1]).to.equal(group);
        expect(loggerImpl.setMetadataCalls[2][2]).to.equal('');
        expect(defaultLogger.getMetadata()).to.deep.equal(rootMetadata);
        expect(defaultGroupLogger.getMetadata()).to.deep.equal(groupLoggerMetadata);
        expect(defaultNamedLogger1.getMetadata()).to.deep.equal(namedLogger1Metadata);
        expect(defaultNamedLogger2.getMetadata()).to.deep.equal({});
    }
};
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkRootLogger", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkRootLogLevel", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkSetRootLogLevel", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkGetImplementation", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkGetNamedLogger", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkSetLogLevel", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkCorrectLogLevelInvocations", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkMetadataArguments", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkSetConfig", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkConfigInheritance", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkSetMetadataOnLoggerFactory", null);
__decorate([
    mocha_typescript_1.test,
    __metadata("design:type", Function),
    __metadata("design:paramtypes", []),
    __metadata("design:returntype", void 0)
], LoggerFactoryTest.prototype, "checkSetMetadata", null);
LoggerFactoryTest = __decorate([
    mocha_typescript_1.suite
], LoggerFactoryTest);
exports.LoggerFactoryTest = LoggerFactoryTest;
//# sourceMappingURL=LoggerFactoryTest.js.map