@venok/core 1.0.0

package/test/services/logger.service.spec.js

@@ -0,0 +1,487 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+require("reflect-metadata");
+const sinon = __importStar(require("sinon"));
+const logger_service_1 = require("@venok/core/services/logger.service");
+const console_service_1 = require("@venok/core/services/console.service");
+describe("Logger", () => {
+    describe("[static methods]", () => {
+        describe("when the default logger is used", () => {
+            let processStdoutWriteSpy;
+            let processStderrWriteSpy;
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+                processStderrWriteSpy = sinon.spy(process.stderr, "write");
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+                processStderrWriteSpy.restore();
+            });
+            it("should print one message to the console", () => {
+                const message = "random message";
+                const context = "RandomContext";
+                logger_service_1.Logger.log(message, context);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print one message without context to the console", () => {
+                const message = "random message without context";
+                logger_service_1.Logger.log(message);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print multiple messages to the console", () => {
+                const messages = ["message 1", "message 2", "message 3"];
+                const context = "RandomContext";
+                logger_service_1.Logger.log(messages[0], messages[1], messages[2], context);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledThrice).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(messages[0]);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(messages[1]);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(messages[2]);
+            });
+            it("should print one error to the console with context", () => {
+                const message = "random error";
+                const context = "RandomContext";
+                logger_service_1.Logger.error(message, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print one error to the console with stacktrace", () => {
+                const message = "random error";
+                const stacktrace = "Error: message\n    at <anonymous>:1:2";
+                logger_service_1.Logger.error(message, stacktrace);
+                (0, chai_1.expect)(processStderrWriteSpy.calledTwice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.not.include(`[]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.equal(stacktrace + "\n");
+            });
+            it("should print one error without context to the console", () => {
+                const message = "random error without context";
+                logger_service_1.Logger.error(message);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print error object without context to the console", () => {
+                const error = new Error("Random text here");
+                logger_service_1.Logger.error(error);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`Error: Random text here`);
+            });
+            it("should serialise a plain JS object (as a message) without context to the console", () => {
+                const error = {
+                    randomError: true,
+                };
+                logger_service_1.Logger.error(error);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`Object:`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`{\n  "randomError": true\n}`);
+            });
+            it("should print one error with stacktrace and context to the console", () => {
+                const message = "random error with context";
+                const stacktrace = "stacktrace";
+                const context = "ErrorContext";
+                logger_service_1.Logger.error(message, stacktrace, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledTwice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.equal(stacktrace + "\n");
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.not.include(context);
+            });
+            it("should print multiple 2 errors and one stacktrace to the console", () => {
+                const messages = ["message 1", "message 2"];
+                const stack = "stacktrace";
+                const context = "RandomContext";
+                logger_service_1.Logger.error(messages[0], messages[1], stack, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledThrice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(messages[0]);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.include(messages[1]);
+                (0, chai_1.expect)(processStderrWriteSpy.thirdCall.firstArg).to.not.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.thirdCall.firstArg).to.equal(stack + "\n");
+            });
+        });
+        describe("when logging is disabled", () => {
+            let processStdoutWriteSpy;
+            let previousLoggerRef;
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+                previousLoggerRef = logger_service_1.Logger["staticInstanceRef"];
+                logger_service_1.Logger.overrideLogger(false);
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+                logger_service_1.Logger.overrideLogger(previousLoggerRef);
+            });
+            it("should not print any message to the console", () => {
+                const message = "random message";
+                const context = "RandomContext";
+                logger_service_1.Logger.log(message, context);
+                (0, chai_1.expect)(processStdoutWriteSpy.called).to.be.false;
+            });
+        });
+        describe("when custom logger is being used", () => {
+            class CustomLogger {
+                log(message, context) { }
+                error(message, trace, context) { }
+                warn(message, context) { }
+            }
+            const customLogger = new CustomLogger();
+            let previousLoggerRef;
+            beforeEach(() => {
+                previousLoggerRef = logger_service_1.Logger["staticInstanceRef"];
+                logger_service_1.Logger.overrideLogger(customLogger);
+            });
+            afterEach(() => {
+                logger_service_1.Logger.overrideLogger(previousLoggerRef);
+            });
+            it('should call custom logger "#log()" method', () => {
+                const message = "random message";
+                const context = "RandomContext";
+                const customLoggerLogSpy = sinon.spy(customLogger, "log");
+                logger_service_1.Logger.log(message, context);
+                (0, chai_1.expect)(customLoggerLogSpy.called).to.be.true;
+                (0, chai_1.expect)(customLoggerLogSpy.calledWith(message, context)).to.be.true;
+            });
+            it('should call custom logger "#error()" method', () => {
+                const message = "random message";
+                const context = "RandomContext";
+                const customLoggerErrorSpy = sinon.spy(customLogger, "error");
+                logger_service_1.Logger.error(message, context);
+                (0, chai_1.expect)(customLoggerErrorSpy.called).to.be.true;
+                (0, chai_1.expect)(customLoggerErrorSpy.calledWith(message, context)).to.be.true;
+            });
+        });
+    });
+    describe("ConsoleLogger", () => {
+        it("should allow setting and resetting of context", () => {
+            const logger = new console_service_1.ConsoleLogger();
+            (0, chai_1.expect)(logger["context"]).to.be.undefined;
+            logger.setContext("context");
+            (0, chai_1.expect)(logger["context"]).to.equal("context");
+            logger.resetContext();
+            (0, chai_1.expect)(logger["context"]).to.be.undefined;
+            const loggerWithContext = new console_service_1.ConsoleLogger("context");
+            (0, chai_1.expect)(loggerWithContext["context"]).to.equal("context");
+            loggerWithContext.setContext("other");
+            (0, chai_1.expect)(loggerWithContext["context"]).to.equal("other");
+            loggerWithContext.resetContext();
+            (0, chai_1.expect)(loggerWithContext["context"]).to.equal("context");
+        });
+        describe("functions for message", () => {
+            let processStdoutWriteSpy;
+            const logger = new console_service_1.ConsoleLogger();
+            const message = "Hello World";
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+            });
+            it("works", () => {
+                logger.log(() => message);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(message);
+                // Ensure we didn't serialize the function itself.
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).not.to.include(" => ");
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).not.to.include("function");
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).not.to.include("Function");
+            });
+        });
+    });
+    describe("[instance methods]", () => {
+        describe("when the default logger is used", () => {
+            const logger = new logger_service_1.Logger();
+            let processStdoutWriteSpy;
+            let processStderrWriteSpy;
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+                processStderrWriteSpy = sinon.spy(process.stderr, "write");
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+                processStderrWriteSpy.restore();
+            });
+            it("should print one message to the console", () => {
+                const message = "random message";
+                const context = "RandomContext";
+                logger.log(message, context);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print one message without context to the console", () => {
+                const message = "random message without context";
+                logger.log(message);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print multiple messages to the console", () => {
+                const messages = ["message 1", "message 2", "message 3"];
+                const context = "RandomContext";
+                logger.log(messages[0], messages[1], messages[2], context);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledThrice).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(messages[0]);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(messages[1]);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(messages[2]);
+            });
+            it("should print one error to the console with context", () => {
+                const message = "random error";
+                const context = "RandomContext";
+                logger.error(message, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print one error to the console with stacktrace", () => {
+                const message = "random error";
+                const stacktrace = "Error: message\n    at <anonymous>:1:2";
+                logger.error(message, stacktrace);
+                (0, chai_1.expect)(processStderrWriteSpy.calledTwice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.not.include(`[]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.equal(stacktrace + "\n");
+            });
+            it("should print one error without context to the console", () => {
+                const message = "random error without context";
+                logger.error(message);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+            });
+            it("should print one error with stacktrace and context to the console", () => {
+                const message = "random error with context";
+                const stacktrace = "stacktrace";
+                const context = "ErrorContext";
+                logger.error(message, stacktrace, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledTwice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.equal(stacktrace + "\n");
+            });
+            it("should print 2 errors and one stacktrace to the console", () => {
+                const messages = ["message 1", "message 2"];
+                const stack = "stacktrace";
+                const context = "RandomContext";
+                logger.error(messages[0], messages[1], stack, context);
+                (0, chai_1.expect)(processStderrWriteSpy.calledThrice).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(messages[0]);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.secondCall.firstArg).to.include(messages[1]);
+                (0, chai_1.expect)(processStderrWriteSpy.thirdCall.firstArg).to.not.include(`[${context}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.thirdCall.firstArg).to.equal(stack + "\n");
+            });
+        });
+        describe("when the default logger is used and global context is set and timestamp enabled", () => {
+            const globalContext = "GlobalContext";
+            const logger = new logger_service_1.Logger(globalContext, { timestamp: true });
+            let processStdoutWriteSpy;
+            let processStderrWriteSpy;
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+                processStderrWriteSpy = sinon.spy(process.stderr, "write");
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+                processStderrWriteSpy.restore();
+            });
+            it("should print multiple messages to the console and append global context", () => {
+                const messages = ["message 1", "message 2", "message 3"];
+                logger.log(messages[0], messages[1], messages[2]);
+                (0, chai_1.expect)(processStdoutWriteSpy.calledThrice).to.be.true;
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(`[${globalContext}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.include(messages[0]);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(`[${globalContext}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include(messages[1]);
+                (0, chai_1.expect)(processStdoutWriteSpy.secondCall.firstArg).to.include("ms");
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(`[${globalContext}]`);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include(messages[2]);
+                (0, chai_1.expect)(processStdoutWriteSpy.thirdCall.firstArg).to.include("ms");
+            });
+            it("should log out an error to stderr but not include an undefined log", () => {
+                const message = "message 1";
+                logger.error(message);
+                (0, chai_1.expect)(processStderrWriteSpy.calledOnce).to.be.true;
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(`[${globalContext}]`);
+                (0, chai_1.expect)(processStderrWriteSpy.firstCall.firstArg).to.include(message);
+            });
+        });
+        describe("when logging is disabled", () => {
+            const logger = new logger_service_1.Logger();
+            let processStdoutWriteSpy;
+            let previousLoggerRef;
+            beforeEach(() => {
+                processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+                previousLoggerRef = logger_service_1.Logger["staticInstanceRef"];
+                logger_service_1.Logger.overrideLogger(false);
+            });
+            afterEach(() => {
+                processStdoutWriteSpy.restore();
+                logger_service_1.Logger.overrideLogger(previousLoggerRef);
+            });
+            it("should not print any message to the console", () => {
+                const message = "random message";
+                const context = "RandomContext";
+                logger.log(message, context);
+                (0, chai_1.expect)(processStdoutWriteSpy.called).to.be.false;
+            });
+        });
+        describe("when custom logger is being used", () => {
+            class CustomLogger {
+                log(message, context) { }
+                error(message, trace, context) { }
+                warn(message, context) { }
+            }
+            describe("with global context", () => {
+                const customLogger = new CustomLogger();
+                const globalContext = "RandomContext";
+                const originalLogger = new logger_service_1.Logger(globalContext);
+                let previousLoggerRef;
+                beforeEach(() => {
+                    previousLoggerRef = logger_service_1.Logger["staticInstanceRef"];
+                    logger_service_1.Logger.overrideLogger(customLogger);
+                });
+                afterEach(() => {
+                    logger_service_1.Logger.overrideLogger(previousLoggerRef);
+                });
+                it('should call custom logger "#log()" method with context as second argument', () => {
+                    const message = "random log message with global context";
+                    const customLoggerLogSpy = sinon.spy(customLogger, "log");
+                    originalLogger.log(message);
+                    (0, chai_1.expect)(customLoggerLogSpy.called).to.be.true;
+                    (0, chai_1.expect)(customLoggerLogSpy.calledWith(message, globalContext)).to.be.true;
+                });
+                it('should call custom logger "#error()" method with context as third argument', () => {
+                    const message = "random error message with global context";
+                    const customLoggerErrorSpy = sinon.spy(customLogger, "error");
+                    originalLogger.error(message);
+                    (0, chai_1.expect)(customLoggerErrorSpy.called).to.be.true;
+                    (0, chai_1.expect)(customLoggerErrorSpy.calledWith(message, undefined, globalContext)).to.be.true;
+                });
+            });
+            describe("without global context", () => {
+                const customLogger = new CustomLogger();
+                const originalLogger = new logger_service_1.Logger();
+                let previousLoggerRef;
+                beforeEach(() => {
+                    previousLoggerRef = logger_service_1.Logger["staticInstanceRef"];
+                    logger_service_1.Logger.overrideLogger(customLogger);
+                });
+                afterEach(() => {
+                    logger_service_1.Logger.overrideLogger(previousLoggerRef);
+                });
+                it('should call custom logger "#log()" method', () => {
+                    const message = "random message";
+                    const context = "RandomContext";
+                    const customLoggerLogSpy = sinon.spy(customLogger, "log");
+                    originalLogger.log(message, context);
+                    (0, chai_1.expect)(customLoggerLogSpy.called).to.be.true;
+                    (0, chai_1.expect)(customLoggerLogSpy.calledWith(message, context)).to.be.true;
+                });
+                it('should call custom logger "#error()" method', () => {
+                    const message = "random message";
+                    const context = "RandomContext";
+                    const customLoggerErrorSpy = sinon.spy(customLogger, "error");
+                    originalLogger.error(message, undefined, context);
+                    (0, chai_1.expect)(customLoggerErrorSpy.called).to.be.true;
+                    (0, chai_1.expect)(customLoggerErrorSpy.calledWith(message, undefined, context)).to.be.true;
+                });
+            });
+        });
+    });
+    describe("ConsoleLogger", () => {
+        let processStdoutWriteSpy;
+        beforeEach(() => {
+            processStdoutWriteSpy = sinon.spy(process.stdout, "write");
+        });
+        afterEach(() => {
+            processStdoutWriteSpy.restore();
+        });
+        it("should support custom formatter", () => {
+            class CustomConsoleLogger extends console_service_1.ConsoleLogger {
+                formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+                    return `Prefix: ${message}`;
+                }
+            }
+            const consoleLogger = new CustomConsoleLogger();
+            consoleLogger.debug("test");
+            (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.equal(`Prefix: test`);
+        });
+        it("should support custom formatter and colorizer", () => {
+            class CustomConsoleLogger extends console_service_1.ConsoleLogger {
+                formatMessage(logLevel, message, pidMessage, formattedLogLevel, contextMessage, timestampDiff) {
+                    const strMessage = this.stringifyMessage(message, logLevel);
+                    return `Prefix: ${strMessage}`;
+                }
+                colorize(message, logLevel) {
+                    return `~~~${message}~~~`;
+                }
+            }
+            const consoleLogger = new CustomConsoleLogger();
+            consoleLogger.debug("test");
+            (0, chai_1.expect)(processStdoutWriteSpy.firstCall.firstArg).to.equal(`Prefix: ~~~test~~~`);
+        });
+        it("should stringify messages", () => {
+            class CustomConsoleLogger extends console_service_1.ConsoleLogger {
+                colorize(message, _) {
+                    return message;
+                }
+            }
+            const consoleLogger = new CustomConsoleLogger();
+            const consoleLoggerSpy = sinon.spy(consoleLogger, "stringifyMessage");
+            consoleLogger.debug("str1", { key: "str2" }, ["str3"], [{ key: "str4" }], null, 1);
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(0).returnValue).to.equal("str1");
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(1).returnValue).to.equal(`Object:
+{
+  "key": "str2"
+}
+`);
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(2).returnValue).to.equal(`Object:
+[
+  "str3"
+]
+`);
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(3).returnValue).to.equal(`Object:
+[
+  {
+    "key": "str4"
+  }
+]
+`);
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(4).returnValue).to.equal(null);
+            (0, chai_1.expect)(consoleLoggerSpy.getCall(5).returnValue).to.equal(1);
+        });
+    });
+});

package/test/services/reflector.service.spec.d.ts

@@ -0,0 +1 @@
+import "reflect-metadata";

package/test/services/reflector.service.spec.js

@@ -0,0 +1,105 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const services_1 = require("@venok/core/services");
+const transformDecorator = services_1.Reflector.createDecorator({
+    transform: (value) => value.length,
+});
+describe("Reflector", () => {
+    let reflector;
+    class Test {
+    }
+    let TestTransform = class TestTransform {
+    };
+    TestTransform = __decorate([
+        transformDecorator(["a", "b", "c"])
+    ], TestTransform);
+    beforeEach(() => {
+        reflector = new services_1.Reflector();
+    });
+    describe("get", () => {
+        it("should reflect metadata by key", () => {
+            const key = "key";
+            const value = "value";
+            Reflect.defineMetadata(key, value, Test);
+            (0, chai_1.expect)(reflector.get(key, Test)).to.eql(value);
+        });
+        it("should reflect metadata by decorator", () => {
+            const decorator = services_1.Reflector.createDecorator();
+            const value = "value";
+            Reflect.defineMetadata(decorator.KEY, value, Test);
+            let reflectedValue = reflector.get(decorator, Test);
+            (0, chai_1.expect)(reflectedValue).to.eql(value);
+            // @ts-expect-error 'value' is not assignable to parameter of type 'string'
+            reflectedValue = true;
+        });
+        it("should reflect metadata by decorator (custom key)", () => {
+            const decorator = services_1.Reflector.createDecorator({ key: "custom" });
+            const value = ["value"];
+            Reflect.defineMetadata("custom", value, Test);
+            let reflectedValue = reflector.get(decorator, Test);
+            (0, chai_1.expect)(reflectedValue).to.eql(value);
+            // @ts-expect-error 'value' is not assignable to parameter of type 'string[]'
+            reflectedValue = true;
+        });
+        it("should reflect metadata by decorator (with transform option)", () => {
+            let reflectedValue = reflector.get(transformDecorator, TestTransform);
+            (0, chai_1.expect)(reflectedValue).to.eql(3);
+            // @ts-expect-error 'value' is not assignable to type 'number'
+            reflectedValue = [];
+        });
+        it("should require transform option when second generic type is provided", () => {
+            // @ts-expect-error Property 'transform' is missing in type {} but required in type
+            const decorator = services_1.Reflector.createDecorator({});
+        });
+    });
+    describe("getAll", () => {
+        it("should reflect metadata of all targets", () => {
+            const key = "key";
+            const value = "value";
+            Reflect.defineMetadata(key, value, Test);
+            (0, chai_1.expect)(reflector.getAll(key, [Test])).to.eql([value]);
+        });
+    });
+    describe("getAllAndMerge", () => {
+        it("should return an empty array when there are no targets", () => {
+            const key = "key";
+            (0, chai_1.expect)(reflector.getAllAndMerge(key, [])).to.be.empty;
+        });
+        it("should reflect metadata of all targets and concat arrays", () => {
+            const key = "key";
+            const value = "value";
+            Reflect.defineMetadata(key, [value], Test);
+            (0, chai_1.expect)(reflector.getAllAndMerge(key, [Test, Test])).to.eql([value, value]);
+        });
+        it("should reflect metadata of all targets and create an array", () => {
+            const key = "key";
+            const value = "value";
+            Reflect.defineMetadata(key, value, Test);
+            (0, chai_1.expect)(reflector.getAllAndMerge(key, [Test, Test])).to.eql([value, value]);
+        });
+        it("should reflect metadata of all targets and merge an object", () => {
+            const key = "key";
+            const value = { test: "test" };
+            Reflect.defineMetadata(key, value, Test);
+            (0, chai_1.expect)(reflector.getAllAndMerge(key, [Test, Test])).to.eql({
+                ...value,
+            });
+        });
+    });
+    describe("getAllAndOverride", () => {
+        it("should reflect metadata of all targets and return a first not undefined value", () => {
+            const key = "key";
+            const value = "value";
+            Reflect.defineMetadata(key, value, Test);
+            (0, chai_1.expect)(reflector.getAllAndOverride(key, [Test, Test])).to.eql(value);
+        });
+    });
+});