init

node_modules/bs-logger/dist/testing/index.d.ts

@@ -0,0 +1,8 @@
+import { CreateLoggerOptions, Logger } from '../logger';
+import { ExtendedArray, LogTargetMock, extendArray } from './target-mock';
+declare const setupForTesting: (target?: LogTargetMock) => void;
+interface LoggerMock extends Logger {
+    readonly target: LogTargetMock;
+}
+declare const createLoggerMock: (options?: CreateLoggerOptions | undefined, target?: LogTargetMock) => LoggerMock;
+export { LogTargetMock, ExtendedArray, extendArray, setupForTesting as setup, createLoggerMock, LoggerMock };

node_modules/bs-logger/dist/testing/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger_1 = require("../logger");
+var root_1 = require("../logger/root");
+var target_mock_1 = require("./target-mock");
+exports.LogTargetMock = target_mock_1.LogTargetMock;
+exports.extendArray = target_mock_1.extendArray;
+var setupForTesting = function (target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    root_1.setup(function () { return createLoggerMock(undefined, target); });
+};
+exports.setup = setupForTesting;
+var createLoggerMock = function (options, target) {
+    if (target === void 0) { target = new target_mock_1.LogTargetMock(); }
+    var opt = __assign({}, options, { targets: [target] });
+    return Object.assign(logger_1.createLogger(opt), { target: target });
+};
+exports.createLoggerMock = createLoggerMock;

node_modules/bs-logger/dist/testing/target-mock.d.ts

@@ -0,0 +1,28 @@
+import { LogMessage } from '../logger/message';
+import { LogTarget } from '../logger/target';
+interface ExtendedArray<T> extends Array<T> {
+    readonly last: T | undefined;
+}
+interface LogLevelMap<T> {
+    trace: T;
+    debug: T;
+    info: T;
+    warn: T;
+    error: T;
+    fatal: T;
+}
+declare const extendArray: <T>(array: T[]) => ExtendedArray<T>;
+declare class LogTargetMock implements LogTarget {
+    minLevel: number;
+    readonly messages: ExtendedArray<LogMessage> & LogLevelMap<ExtendedArray<LogMessage>>;
+    readonly lines: ExtendedArray<string> & LogLevelMap<ExtendedArray<string>>;
+    readonly stream: LogTarget['stream'];
+    constructor(minLevel?: number);
+    format(msg: LogMessage): string;
+    clear(): void;
+    filteredMessages(level: number, untilLevel?: number): ExtendedArray<LogMessage>;
+    filteredMessages(level: null): ExtendedArray<LogMessage>;
+    filteredLines(level: number, untilLevel?: number): ExtendedArray<string>;
+    filteredLines(level: null): ExtendedArray<string>;
+}
+export { LogTargetMock, extendArray, ExtendedArray };

node_modules/bs-logger/dist/testing/target-mock.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var context_1 = require("../logger/context");
+var level_1 = require("../logger/level");
+var extendArray = function (array) {
+    return Object.defineProperty(array, 'last', {
+        configurable: true,
+        get: function () {
+            return this[this.length - 1];
+        },
+    });
+};
+exports.extendArray = extendArray;
+var LogTargetMock = (function () {
+    function LogTargetMock(minLevel) {
+        if (minLevel === void 0) { minLevel = -Infinity; }
+        var _this = this;
+        this.minLevel = minLevel;
+        this.messages = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredMessages(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredMessages(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredMessages(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredMessages(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredMessages(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredMessages(level_1.LogLevels.fatal); } },
+        });
+        this.lines = Object.defineProperties(extendArray([]), {
+            trace: { get: function () { return _this.filteredLines(level_1.LogLevels.trace); } },
+            debug: { get: function () { return _this.filteredLines(level_1.LogLevels.debug); } },
+            info: { get: function () { return _this.filteredLines(level_1.LogLevels.info); } },
+            warn: { get: function () { return _this.filteredLines(level_1.LogLevels.warn); } },
+            error: { get: function () { return _this.filteredLines(level_1.LogLevels.error); } },
+            fatal: { get: function () { return _this.filteredLines(level_1.LogLevels.fatal); } },
+        });
+        this.stream = {
+            write: function (msg) { return !!_this.lines.push(msg); },
+        };
+    }
+    LogTargetMock.prototype.format = function (msg) {
+        this.messages.push(msg);
+        var lvl = msg.context[context_1.LogContexts.logLevel];
+        if (lvl != null) {
+            return "[level:" + lvl + "] " + msg.message;
+        }
+        return msg.message;
+    };
+    LogTargetMock.prototype.clear = function () {
+        this.messages.splice(0, this.messages.length);
+        this.lines.splice(0, this.lines.length);
+    };
+    LogTargetMock.prototype.filteredMessages = function (level, untilLevel) {
+        var filter;
+        if (level == null) {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] == null; };
+        }
+        else if (untilLevel != null) {
+            filter = function (m) {
+                var lvl = m.context[context_1.LogContexts.logLevel];
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (m) { return m.context[context_1.LogContexts.logLevel] === level; };
+        }
+        return extendArray(this.messages.filter(filter));
+    };
+    LogTargetMock.prototype.filteredLines = function (level, untilLevel) {
+        var extractLevel = function (line) {
+            var level = (line.match(/^\[level:([0-9]+)\] /) || [])[1];
+            return level == null ? undefined : parseInt(level, 10);
+        };
+        var filter;
+        if (level == null) {
+            filter = function (line) { return extractLevel(line) === undefined; };
+        }
+        else if (untilLevel != null) {
+            filter = function (line) {
+                var lvl = extractLevel(line);
+                return lvl != null && lvl >= level && lvl <= untilLevel;
+            };
+        }
+        else {
+            filter = function (line) { return extractLevel(line) === level; };
+        }
+        return extendArray(this.lines.filter(filter));
+    };
+    return LogTargetMock;
+}());
+exports.LogTargetMock = LogTargetMock;