standard-log 8.0.0 → 9.0.1

package/cjs/standardLog.spec.js

@@ -0,0 +1,548 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var assertron_1 = require("assertron");
+var errors_js_1 = require("./errors.js");
+var logLevels_js_1 = require("./logLevels.js");
+var memory_js_1 = require("./memory.js");
+var standardLog_js_1 = require("./standardLog.js");
+var testUtil_js_1 = require("./testUtil.js");
+describe('createStandardLog()', function () {
+    describe('logLevel', function () {
+        it('is default to info', function () {
+            var actual = (0, standardLog_js_1.createStandardLog)();
+            expect(actual.logLevel).toBe(logLevels_js_1.logLevels.info);
+        });
+        it('is readonly', function () {
+            var actual = (0, standardLog_js_1.createStandardLog)();
+            assertron_1.assertron.throws(function () { return actual.logLevel = logLevels_js_1.logLevels.planck; }, function (err) { return /only a getter/.test(err); });
+        });
+        it('set logLevel from options', function () {
+            var actual = (0, standardLog_js_1.createStandardLog)({ logLevel: logLevels_js_1.logLevels.planck });
+            expect(actual.logLevel).toBe(logLevels_js_1.logLevels.planck);
+        });
+    });
+    describe('custom levels', function () {
+        it('can define custom levels', function () {
+            var actual = (0, standardLog_js_1.createStandardLog)({ customLevels: { urgent: 80 } });
+            expect(actual.toLogLevelName(80)).toBe('urgent');
+        });
+    });
+    describe('reporters', function () {
+        it('can specify reporter', function () {
+            var mem = (0, memory_js_1.createMemoryLogReporter)();
+            var sl = (0, standardLog_js_1.createStandardLog)({ reporters: [mem] });
+            var log = sl.getLogger(['x']);
+            log.info('abc');
+            expect(mem.logs.length).toBe(1);
+        });
+    });
+});
+describe('createStandardLogForTest()', function () {
+    it('returns with memory reporter', function () {
+        var reporter = (0, standardLog_js_1.createStandardLogForTest)().reporter;
+        expect(reporter.getLogMessageWithLevel()).toBe('');
+    });
+    it('defaults to debug', function () {
+        var store = (0, standardLog_js_1.createStandardLogForTest)();
+        expect(store.logLevel).toBe(logLevels_js_1.logLevels.debug);
+    });
+});
+describe('getLogger()', function () {
+    it('supports id with alphanumeric and :_-.', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        sl.getLogger(['abcdefghijklmnopqrstuvwxyz:-_.1234567890']);
+    });
+    it('supports id with unicode', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        sl.getLogger(['ミク香港']);
+    });
+    it('supports id with @, \\ and /', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        sl.getLogger(['@unional/fixture']);
+        sl.getLogger(["a\\b\\c"]);
+    });
+    it.each('`~!#$%^&*()=+|[]{}<>,?'.split(''))('throws if id has unsupported character %s', function (char) {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        assertron_1.assertron.throws(function () { return sl.getLogger([char]); }, errors_js_1.InvalidId);
+    });
+    it('throw InvalidId with ssf to the call site', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        var err = assertron_1.assertron.throws(function () { return sl.getLogger(['!']); }, errors_js_1.InvalidId);
+        (0, testUtil_js_1.assertSSF)(err, __filename);
+    });
+    test('id is readonly', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        var log = sl.getLogger(['id is readonly']);
+        assertron_1.assertron.throws(function () { return log.id = 'b'; });
+    });
+    test('get logger with same name gets the same instance', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        var expected = sl.getLogger(['same-inst']);
+        var actual = sl.getLogger(['same-inst']);
+        expect(actual).toBe(expected);
+    });
+    it('can specify local log level', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        var log = sl.getLogger(['local', { level: logLevels_js_1.logLevels.trace }]);
+        expect(log.level).toBe(logLevels_js_1.logLevels.trace);
+    });
+    test('new logger will get custom level', function () {
+        var sl = (0, standardLog_js_1.createStandardLog)({ customLevels: { 'to_logger': 1234 } });
+        var actual = sl.getLogger(['to_logger_logger']);
+        expect(typeof actual.to_logger).toBe('function');
+    });
+    it('Logger have at least the default log method names', function () {
+        function wrapper(options) {
+            var sl = (0, standardLog_js_1.createStandardLog)(options);
+            // since `N` is generic, just `Logger<N>` will not have the default log method names.
+            var log = sl.getLogger(['local']);
+            expect(log.info).toBeDefined();
+            return sl;
+        }
+        var sl = wrapper({ customLevels: { 'cust': 123 } });
+        var actual = sl.getLogger(['c']);
+        expect(actual.cust).toBeDefined();
+    });
+    describe('log levels', function () {
+        function assertLoggedAtLevel(sl, method, level) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log, msg;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method]);
+                    msg = "should log on level: ".concat(level);
+                    log[method](msg);
+                    assertron_1.assertron.satisfies(sl.reporter.logs, [{ id: method, level: sl.toLogLevel(method), args: [msg] }]);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertNotLoggedAtLevel(sl, method, level) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method]);
+                    log[method]("should not log on level: ".concat(level));
+                    expect(sl.reporter.logs.length).toBe(0);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertLoggedAtLocalLevel(sl, method, localLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log, msg;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method, { level: localLevel }]);
+                    msg = "should log on level: ".concat(localLevel);
+                    log[method](msg);
+                    assertron_1.assertron.satisfies(sl.reporter.logs, [{ id: log.id, level: sl.toLogLevel(method), args: [msg] }]);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertNotLoggedAtLocalLevel(sl, method, localLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method, { level: localLevel }]);
+                    log[method]("should not log on level: ".concat(localLevel));
+                    expect(sl.reporter.logs.length).toBe(0);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertLoggedAtCallLevel(sl, method, callLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log, actual;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method]);
+                    actual = false;
+                    log.on(callLevel, function () { return actual = true; });
+                    expect(actual).toBe(true);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertNotLoggedAtCallLevel(sl, method, callLevel, actualLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method]);
+                    log.on(callLevel, function () { throw new Error("should not log at level ".concat(actualLevel)); });
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log, actual;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method, { level: localLevel }]);
+                    actual = false;
+                    log.on(callLevel, function () { return actual = true; });
+                    expect(actual).toBe(true);
+                    return [2 /*return*/];
+                });
+            });
+        }
+        function assertNotLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel) {
+            return __awaiter(this, void 0, void 0, function () {
+                var log;
+                return __generator(this, function (_a) {
+                    log = sl.getLogger([method, { level: localLevel }]);
+                    log.on(callLevel, function () { throw new Error("should not log at level ".concat(localLevel)); });
+                    return [2 /*return*/];
+                });
+            });
+        }
+        var shouldLog = (0, testUtil_js_1.wrapTest)(function (test) { return function (method, level) {
+            var sl = (0, standardLog_js_1.createStandardLogForTest)(level);
+            var name = sl.toLogLevelName(level);
+            test("".concat(method, "() should log on level: ").concat(name, " (").concat(level, ")"), function () {
+                return assertLoggedAtLevel(sl, method, level);
+            });
+        }; });
+        var shouldNotLog = (0, testUtil_js_1.wrapTest)(function (test) { return function (method, level) {
+            var sl = (0, standardLog_js_1.createStandardLogForTest)(level);
+            var name = sl.toLogLevelName(level);
+            test("".concat(method, "() should not log on level: ").concat(name, " (").concat(level, ")"), function () {
+                return assertNotLoggedAtLevel(sl, method, level);
+            });
+        }; });
+        var shouldLogWithLocalLevelOverride = (0, testUtil_js_1.wrapTest)(function (test) { return function (method, localLevel) {
+            var localName = (0, logLevels_js_1.toLogLevelName)(localLevel);
+            [logLevels_js_1.logLevels.none, logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug].forEach(function (globalLevel) {
+                var globalName = (0, logLevels_js_1.toLogLevelName)(globalLevel) || 'none';
+                test("".concat(method, "() should log on local level: ").concat(localName, " (").concat(localLevel, ") while global level: ").concat(globalName, " (").concat(globalLevel, ")"), function () {
+                    var sl = (0, standardLog_js_1.createStandardLogForTest)(globalLevel);
+                    return assertLoggedAtLocalLevel(sl, method, localLevel);
+                });
+            });
+        }; });
+        var shouldNotLogWithLocalLevelOverride = (0, testUtil_js_1.wrapTest)(function (test) { return function (method, localLevel) {
+            var localName = (0, logLevels_js_1.toLogLevelName)(localLevel);
+            [logLevels_js_1.logLevels.none, logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug].forEach(function (globalLevel) {
+                var globalName = (0, logLevels_js_1.toLogLevelName)(globalLevel) || 'none';
+                test("".concat(method, "() should not log on local level: ").concat(localName, " (").concat(localLevel, ") while global level: ").concat(globalName, " (").concat(globalLevel, ")"), function () {
+                    var sl = (0, standardLog_js_1.createStandardLogForTest)(globalLevel);
+                    return assertNotLoggedAtLocalLevel(sl, method, localLevel);
+                });
+            });
+        }; });
+        var shouldCallLogFunction = (0, testUtil_js_1.wrapTest)(function (test) { return function (callLevel, actualLevel) {
+            var method = (0, logLevels_js_1.toLogLevelName)(callLevel);
+            var name = (0, logLevels_js_1.toLogLevelName)(actualLevel);
+            test("".concat(method, "() should call log function on level: ").concat(name, " (").concat(actualLevel, ")"), function () {
+                var sl = (0, standardLog_js_1.createStandardLogForTest)(actualLevel);
+                return assertLoggedAtCallLevel(sl, method, callLevel);
+            });
+        }; });
+        var shouldNotCallLogFunction = (0, testUtil_js_1.wrapTest)(function (test) { return function (callLevel, actualLevel) {
+            var method = (0, logLevels_js_1.toLogLevelName)(callLevel);
+            var name = (0, logLevels_js_1.toLogLevelName)(actualLevel);
+            test("".concat(method, "() should not call log function on level: ").concat(name, " (").concat(actualLevel, ")"), function () {
+                var sl = (0, standardLog_js_1.createStandardLogForTest)(actualLevel);
+                return assertNotLoggedAtCallLevel(sl, method, callLevel, actualLevel);
+            });
+        }; });
+        var shouldCallLogFunctionWithLocalLevelOverride = (0, testUtil_js_1.wrapTest)(function (test) { return function (callLevel, localLevel) {
+            var method = (0, logLevels_js_1.toLogLevelName)(callLevel);
+            var localName = (0, logLevels_js_1.toLogLevelName)(localLevel);
+            [logLevels_js_1.logLevels.none, logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug].forEach(function (globalLevel) {
+                var globalName = (0, logLevels_js_1.toLogLevelName)(globalLevel) || 'none';
+                test("".concat(method, "() should log on local level: ").concat(localName, " (").concat(localLevel, ") while global level: ").concat(globalName, " (").concat(globalLevel, ")"), function () {
+                    var sl = (0, standardLog_js_1.createStandardLogForTest)(globalLevel);
+                    return assertLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel);
+                });
+            });
+        }; });
+        var shouldNotCallLogFunctionWithLocalLevelOverride = (0, testUtil_js_1.wrapTest)(function (test) { return function (callLevel, localLevel) {
+            var method = (0, logLevels_js_1.toLogLevelName)(callLevel);
+            var localName = (0, logLevels_js_1.toLogLevelName)(localLevel);
+            [logLevels_js_1.logLevels.none, logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug].forEach(function (globalLevel) {
+                var globalName = (0, logLevels_js_1.toLogLevelName)(globalLevel) || 'none';
+                test("".concat(method, "() should not log on local level: ").concat(localName, " (").concat(localLevel, ") while global level: ").concat(globalName, " (").concat(globalLevel, ")"), function () {
+                    var sl = (0, standardLog_js_1.createStandardLogForTest)(globalLevel);
+                    return assertNotLoggedAtCallLevelOverrideLocalLevel(sl, method, localLevel, callLevel);
+                });
+            });
+        }; });
+        shouldNotLog('error', logLevels_js_1.logLevels.none);
+        shouldLog('error', logLevels_js_1.logLevels.error);
+        shouldLog('error', logLevels_js_1.logLevels.warn);
+        shouldLog('error', logLevels_js_1.logLevels.info);
+        shouldLog('error', logLevels_js_1.logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('error', logLevels_js_1.logLevels.none);
+        shouldLogWithLocalLevelOverride('error', logLevels_js_1.logLevels.error);
+        shouldLogWithLocalLevelOverride('error', logLevels_js_1.logLevels.warn);
+        shouldLogWithLocalLevelOverride('error', logLevels_js_1.logLevels.info);
+        shouldLogWithLocalLevelOverride('error', logLevels_js_1.logLevels.debug);
+        shouldNotLog('warn', logLevels_js_1.logLevels.none);
+        shouldNotLog('warn', logLevels_js_1.logLevels.error);
+        shouldLog('warn', logLevels_js_1.logLevels.warn);
+        shouldLog('warn', logLevels_js_1.logLevels.info);
+        shouldLog('warn', logLevels_js_1.logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('warn', logLevels_js_1.logLevels.none);
+        shouldNotLogWithLocalLevelOverride('warn', logLevels_js_1.logLevels.error);
+        shouldLogWithLocalLevelOverride('warn', logLevels_js_1.logLevels.warn);
+        shouldLogWithLocalLevelOverride('warn', logLevels_js_1.logLevels.info);
+        shouldLogWithLocalLevelOverride('warn', logLevels_js_1.logLevels.debug);
+        shouldNotLog('info', logLevels_js_1.logLevels.none);
+        shouldNotLog('info', logLevels_js_1.logLevels.error);
+        shouldNotLog('info', logLevels_js_1.logLevels.warn);
+        shouldLog('info', logLevels_js_1.logLevels.info);
+        shouldLog('info', logLevels_js_1.logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('info', logLevels_js_1.logLevels.none);
+        shouldNotLogWithLocalLevelOverride('info', logLevels_js_1.logLevels.error);
+        shouldNotLogWithLocalLevelOverride('info', logLevels_js_1.logLevels.warn);
+        shouldLogWithLocalLevelOverride('info', logLevels_js_1.logLevels.info);
+        shouldLogWithLocalLevelOverride('info', logLevels_js_1.logLevels.debug);
+        shouldNotLog('debug', logLevels_js_1.logLevels.none);
+        shouldNotLog('debug', logLevels_js_1.logLevels.error);
+        shouldNotLog('debug', logLevels_js_1.logLevels.warn);
+        shouldNotLog('debug', logLevels_js_1.logLevels.info);
+        shouldLog('debug', logLevels_js_1.logLevels.debug);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels_js_1.logLevels.none);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels_js_1.logLevels.error);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels_js_1.logLevels.warn);
+        shouldNotLogWithLocalLevelOverride('debug', logLevels_js_1.logLevels.info);
+        shouldLogWithLocalLevelOverride('debug', logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.none);
+        shouldCallLogFunction(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.error);
+        shouldCallLogFunction(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunction(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.info);
+        shouldCallLogFunction(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.none);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.error);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.error, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.error);
+        shouldCallLogFunction(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunction(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info);
+        shouldCallLogFunction(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.error);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.warn, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.error);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunction(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.info);
+        shouldCallLogFunction(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.error);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.warn);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.info, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.error);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.warn);
+        shouldNotCallLogFunction(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.info);
+        shouldCallLogFunction(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.debug);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.none);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.error);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.warn);
+        shouldNotCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.info);
+        shouldCallLogFunctionWithLocalLevelOverride(logLevels_js_1.logLevels.debug, logLevels_js_1.logLevels.debug);
+    });
+    it('writes entry directly', function () {
+        var sl = (0, standardLog_js_1.createStandardLogForTest)();
+        var log = sl.getLogger(['write-entry']);
+        var entry = { id: 'write-entry', level: logLevels_js_1.logLevels.info, args: ['abc'], timestamp: new Date() };
+        log.write(entry);
+        assertron_1.assertron.satisfies(sl.reporter.logs, [entry]);
+    });
+    test.each(['on', 'count', 'error', 'warn', 'info', 'debug'])('method %s is readonly', function (name) {
+        var sl = (0, standardLog_js_1.createStandardLog)();
+        var log = sl.getLogger(["".concat(name, " is readonly")]);
+        assertron_1.assertron.throws(function () { return log[name] = true; });
+    });
+    describe('on()', function () {
+        it('log using log argument', function () {
+            var sl = (0, standardLog_js_1.createStandardLogForTest)();
+            var logger = sl.getLogger(['log on fn']);
+            logger.on('error', function (log) { log('value'); });
+            assertron_1.assertron.satisfies(sl.reporter.logs, [
+                { id: 'log on fn', level: logLevels_js_1.logLevels.error, args: ['value'] }
+            ]);
+        });
+        it('can take log level name in first argument', function () {
+            var sl = (0, standardLog_js_1.createStandardLogForTest)();
+            var log = sl.getLogger(['string-on']);
+            log.on('debug', function () { return; });
+        });
+    });
+    describe('count()', function () {
+        test('will increment the counter', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var sl, logger;
+            return __generator(this, function (_a) {
+                sl = (0, standardLog_js_1.createStandardLogForTest)();
+                logger = sl.getLogger(['inc counter']);
+                logger.count();
+                logger.count();
+                assertron_1.assertron.satisfies(sl.reporter.logs, [
+                    { id: 'inc counter', level: logLevels_js_1.logLevels.debug, args: [1] },
+                    { id: 'inc counter', level: logLevels_js_1.logLevels.debug, args: [2] }
+                ]);
+                return [2 /*return*/];
+            });
+        }); });
+        test('append args after the counter', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var sl, id, logger;
+            return __generator(this, function (_a) {
+                sl = (0, standardLog_js_1.createStandardLogForTest)(logLevels_js_1.logLevels.debug);
+                id = 'inc with args';
+                logger = sl.getLogger([id]);
+                logger.count('msg1', 'msg2');
+                assertron_1.assertron.satisfies(sl.reporter.logs, [
+                    { id: id, level: logLevels_js_1.logLevels.debug, args: [1, 'msg1', 'msg2'] }
+                ]);
+                return [2 /*return*/];
+            });
+        }); });
+        test('not log if log level is less than debug', function () { return __awaiter(void 0, void 0, void 0, function () {
+            var sl, id, logger;
+            return __generator(this, function (_a) {
+                sl = (0, standardLog_js_1.createStandardLogForTest)(logLevels_js_1.logLevels.debug - 1);
+                id = 'inc with args';
+                logger = sl.getLogger([id]);
+                logger.count('msg1', 'msg2');
+                expect(sl.reporter.logs.length).toBe(0);
+                return [2 /*return*/];
+            });
+        }); });
+    });
+    test('logger with custom level', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mem, sl, logger;
+        return __generator(this, function (_a) {
+            mem = (0, memory_js_1.createMemoryLogReporter)();
+            sl = (0, standardLog_js_1.createStandardLog)({ customLevels: { 'cust_lvl': 100 }, reporters: [mem] });
+            logger = sl.getLogger(['cust']);
+            logger.cust_lvl('a', 'b');
+            assertron_1.assertron.satisfies(mem.logs, [{ id: 'cust', level: 100, args: ['a', 'b'] }]);
+            return [2 /*return*/];
+        });
+    }); });
+    describe('getLogger([,{ writeTo }])', function () {
+        function testWriteTo(loggerParams, handler) {
+            var memReporter = (0, memory_js_1.createMemoryLogReporter)();
+            var specialReporter = (0, memory_js_1.createMemoryLogReporter)({ id: 'special' });
+            var sl = (0, standardLog_js_1.createStandardLog)({ reporters: [memReporter, specialReporter] });
+            var log = sl.getLogger(loggerParams);
+            handler(log, memReporter.logs, specialReporter.logs, sl);
+        }
+        it('can specify which reporter to use by name', function () {
+            testWriteTo(['writeTo-string', { writeTo: 'special' }], function (log, memLogs, specialLogs) {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by regex', function () {
+            testWriteTo(['writeTo-regex', { writeTo: /^spec/ }], function (log, memLogs, specialLogs) {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by RegExp', function () {
+            testWriteTo(['writeTo-RegExp', { writeTo: new RegExp('^spec') }], function (log, memLogs, specialLogs) {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify which reporter to use by function', function () {
+            testWriteTo(['writeTo-fn', { writeTo: function (id) { return id === 'special'; } }], function (log, memLogs, specialLogs) {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(1);
+            });
+        });
+        it('can specify custom reporter', function () {
+            var reporter = (0, memory_js_1.createMemoryLogReporter)({ id: 'custom mem' });
+            testWriteTo(['writeTo-reporter', { writeTo: reporter }], function (log, memLogs, specialLogs) {
+                log.error('error message');
+                expect(memLogs.length).toEqual(0);
+                expect(specialLogs.length).toEqual(0);
+                expect(reporter.logs.length).toEqual(1);
+            });
+        });
+        test('the custom console reporter cannot pick up logs from other loggers', function () {
+            // if not, it would be a security issue as the new reporter
+            // can capture the logs from other logger and send it elsewhere
+            var reporter = (0, memory_js_1.createMemoryLogReporter)({ id: 'custom mem' });
+            testWriteTo(['writeTo-reporter-no-override', { writeTo: reporter }], function (_, memLogs, specialLogs, sl) {
+                var log = sl.getLogger(['writeTo-reporter-no-override-2']);
+                log.error('error message');
+                expect(reporter.logs.length).toEqual(0);
+            });
+        });
+    });
+});
+describe('suppressLogs()', function () {
+    test('suppress log', function () {
+        var sl = (0, standardLog_js_1.createStandardLogForTest)();
+        var log = sl.getLogger(['l']);
+        (0, standardLog_js_1.suppressLogs)(function () {
+            log.alert('should not see me');
+        }, log);
+        expect(sl.reporter.getLogMessageWithLevel()).toBe('');
+    });
+    test('suppress multiple logs', function () {
+        var sl = (0, standardLog_js_1.createStandardLogForTest)();
+        var log1 = sl.getLogger(['l1']);
+        var log2 = sl.getLogger(['l2']);
+        (0, standardLog_js_1.suppressLogs)(function () {
+            log1.alert('should not see me');
+            log2.alert('should not see me too');
+        }, log1, log2);
+        expect(sl.reporter.getLogMessageWithLevel()).toBe('');
+    });
+    test('return block result', function () {
+        var sl = (0, standardLog_js_1.createStandardLogForTest)();
+        var log1 = sl.getLogger(['l']);
+        var log2 = sl.getLogger(['l2']);
+        var a = (0, standardLog_js_1.suppressLogs)(function () { return 1; }, log1, log2);
+        expect(a).toBe(1);
+    });
+});
+//# sourceMappingURL=standardLog.spec.js.map