WIP on justinkames#23

Implement logger change and test

Author: tuvokki

src/vue-logger/interfaces/logger.ts

@@ -1,7 +1,9 @@
-import {ILoggerOptions} from "./logger-options";
+import { ILoggerOptions } from "./logger-options";
 
 export interface ILogger {
     install(Vue: any, options: ILoggerOptions);
 
     isValidOptions(options: ILoggerOptions, logLevels: string[]): boolean;
+
+    changeLogLevel(logLevel: string);
 }

src/vue-logger/vue-logger.ts

@@ -1,23 +1,43 @@
-import {LogLevels} from "./enum/log-levels";
-import {ILogger} from "./interfaces/logger";
-import {ILoggerOptions} from "./interfaces/logger-options";
+import { LogLevels } from "./enum/log-levels";
+import { ILogger } from "./interfaces/logger";
+import { ILoggerOptions } from "./interfaces/logger-options";
 
 class VueLogger implements ILogger {
 
     private errorMessage: string = "Provided options for vuejs-logger are not valid.";
     private logLevels: string[] = Object.keys(LogLevels).map((l) => l.toLowerCase());
+    private options: ILoggerOptions = this.getDefaultOptions();
+    private vueInstance: any;
 
     public install(Vue: any, options: ILoggerOptions) {
-        options = Object.assign(this.getDefaultOptions(), options);
+        this.options = Object.assign(this.options, options);
 
         if (this.isValidOptions(options, this.logLevels)) {
+            this.vueInstance = Vue;
             Vue.$log = this.initLoggerInstance(options, this.logLevels);
             Vue.prototype.$log = Vue.$log;
         } else {
             throw new Error(this.errorMessage);
         }
     }
 
+    /**
+     * Create a new logger with nother logLevel.
+     * Exposed on the $log object to set the loglevel.
+     * Implicitly enables the logger.
+     * 
+     * @param aLogLevel the new loglevel
+     */
+    private changeLogLevel(aLogLevel: string) {
+        this.logLevels.forEach((logLevel) => {
+            if (this.logLevels.indexOf(logLevel) >= this.logLevels.indexOf(aLogLevel)) {
+                this.vueInstance.$log[logLevel] = this.createLoggerObject(this.options, logLevel);
+            } else {
+                this.vueInstance.$log[logLevel] = () => undefined;
+            }
+        });
+    }
+
     public isValidOptions(options: ILoggerOptions, logLevels: string[]): boolean {
         if (!(options.logLevel && typeof options.logLevel === "string" && logLevels.indexOf(options.logLevel) > -1)) {
             return false;
@@ -65,24 +85,29 @@ class VueLogger implements ILogger {
     private initLoggerInstance(options: ILoggerOptions, logLevels: string[]) {
         const logger = {};
         logLevels.forEach((logLevel) => {
-                if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel) && options.isEnabled) {
-                    logger[logLevel] = (...args) => {
-                        const methodName = this.getMethodName();
-                        const methodNamePrefix = options.showMethodName ? methodName + ` ${options.separator} ` : "";
-                        const logLevelPrefix = options.showLogLevel ? logLevel + ` ${options.separator} ` : "";
-                        const formattedArguments = options.stringifyArguments ? args.map((a) => JSON.stringify(a)) : args;
-                        const logMessage = `${logLevelPrefix} ${methodNamePrefix}`;
-                        this.printLogMessage(logLevel, logMessage, options.showConsoleColors, formattedArguments);
-                        return `${logMessage} ${formattedArguments.toString()}`;
-                    };
-                } else {
-                    logger[logLevel] = () => undefined;
-                }
-            },
+            if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel) && options.isEnabled) {
+                logger[logLevel] = this.createLoggerObject(options, logLevel);
+            } else {
+                logger[logLevel] = () => undefined;
+            }
+        },
         );
+        logger['changeLogLevel'] = this.changeLogLevel.bind(this)
         return logger;
     }
 
+    private createLoggerObject(options: ILoggerOptions, logLevel: string) {
+        return (...args) => {
+            const methodName = this.getMethodName();
+            const methodNamePrefix = options.showMethodName ? methodName + ` ${options.separator} ` : "";
+            const logLevelPrefix = options.showLogLevel ? logLevel + ` ${options.separator} ` : "";
+            const formattedArguments = options.stringifyArguments ? args.map((a) => JSON.stringify(a)) : args;
+            const logMessage = `${logLevelPrefix} ${methodNamePrefix}`;
+            this.printLogMessage(logLevel, logMessage, options.showConsoleColors, formattedArguments);
+            return `${logMessage} ${formattedArguments.toString()}`;
+        };
+    }
+
     private printLogMessage(logLevel: string, logMessage: string, showConsoleColors: boolean, formattedArguments: any) {
         if (showConsoleColors && (logLevel === "warn" || logLevel === "error" || logLevel === "fatal")) {
             console[logLevel === "fatal" ? "error" : logLevel](logMessage, ...formattedArguments);

tests/changelevel.test.ts

@@ -0,0 +1,35 @@
+import { notStrictEqual, strictEqual } from "assert";
+import chai from "chai";
+import Vue from "vue/dist/vue.min";
+import VueLogger from "../src";
+import { LogLevels } from "../src/vue-logger/enum/log-levels";
+import { ILoggerOptions } from "../src/vue-logger/interfaces/logger-options";
+const expect = chai.expect;
+
+describe("changeLoglevel()", () => {
+
+    test("changeLogLevel('info') should set the loglevel to info after initialisation.", () => {
+        const options: ILoggerOptions = {
+            isEnabled: true,
+            logLevel: LogLevels.ERROR,
+            separator: "|",
+            stringifyArguments: false,
+            showConsoleColors: true,
+            showLogLevel: false,
+            showMethodName: false,
+        };
+        Vue.use(VueLogger, options);
+        expect(Vue.$log).to.be.a("object");
+        strictEqual(Vue.$log.debug("debug"), undefined);
+        strictEqual(Vue.$log.info("info"), undefined);
+        strictEqual(Vue.$log.warn("warn"), undefined);
+        expect(Vue.$log.error("error")).to.exist;
+        expect(Vue.$log.fatal("fatal")).to.exist;
+        Vue.$log.changeLogLevel('info');
+        strictEqual(Vue.$log.debug("debug"), undefined);
+        expect(Vue.$log.error("info")).to.exist;
+        expect(Vue.$log.error("warn")).to.exist;
+        expect(Vue.$log.error("error")).to.exist;
+        expect(Vue.$log.error("fatal")).to.exist;
+    });
+});