test: add unit test to consolelogger.ts

Author: eldreygalindo

packages/opencensus-core/package-lock.json

@@ -57,6 +57,7 @@
     "async_hooks": "^1.0.0",
     "continuation-local-storage": "^3.2.1",
     "debug": "^3.1.0",
+    "intercept-stdout": "^0.1.2",
     "log-driver": "^1.2.7",
     "semver": "^5.5.0",
     "shimmer": "^1.2.0",

packages/opencensus-core/package.json

@@ -16,11 +16,12 @@
 
 import {Logger, LoggerOptions} from './types';
 
-let logDriver = require('log-driver');
+const logDriver = require('log-driver');
 
 
  class ConsoleLogger implements Logger {
 
+  // tslint:disable:no-any
   private logger:any; 
   static LEVELS = ['error', 'warn', 'info', 'debug', 'silly'];
 
@@ -29,7 +30,7 @@ let logDriver = require('log-driver');
     if (typeof options === "string") {
       opt = {
         level: options
-      }
+      };
     } else {
       opt = options || {};
     }
@@ -40,30 +41,35 @@ let logDriver = require('log-driver');
     });
   }
 
+  // tslint:disable:no-any
   error(message: any, ...args: any[]): void {
     this.logger.error(arguments);
   }
 
+  // tslint:disable:no-any
   warn(message: any, ...args: any[]): void {
     this.logger.warn(arguments);
   }
 
+  // tslint:disable:no-any
   info(message: any, ...args: any[]): void {
     this.logger.info(arguments);
   }
 
+  // tslint:disable:no-any
   debug (message: any, ...args: any[]): void {
     this.logger.debug(arguments);
   }
 
+  // tslint:disable:no-any
   silly (message: any, ...args: any[]): void {
     this.logger.silly(arguments);
   }
 }
 
 let defaultLogger = null;
 
-let logger  = function(options?: LoggerOptions|string){
+const logger  = (options?: LoggerOptions|string) => {
   defaultLogger = new ConsoleLogger(options);
   logger['logger'] = defaultLogger;
   return defaultLogger;

packages/opencensus-core/src/common/console-logger.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+ // tslint:disable:no-any
 export type LogFunction = (message: any, ...args: any[]) => void;
 
 export interface Logger {

packages/opencensus-core/src/common/types.ts

@@ -1,19 +1,179 @@
+/**
+ * Copyright 2018 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the 'License');
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an 'AS IS' BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 import * as assert from 'assert';
 import * as mocha from 'mocha';
-
 import * as logger from '../src/common/consolelogger';
 
+const LEVELS = ['error', 'warn', 'info', 'debug', 'silly'];
+let consoleTxt = '';
+
+
+
 
 describe('ConsoleLogger', () => {
-    describe('new RootSpan()', () => {
-        it('should create a RootSpan instance', () => {
-            const consoleLogger = logger({level: 'error'});
-            
-            consoleLogger.info("info");
-            consoleLogger.error("error");
-            
-            assert.ok(true);
-        });
+  const intercept = require('intercept-stdout');
+  const unhookIntercept = intercept((txt) => {
+    consoleTxt = txt;
+    return txt;
+  });
+  describe('new ConsoleLogger()', () => {
+    it('should levels from consoleLogger equals default levels', () => {
+      const consoleLogger = logger();
+      assert.equal(LEVELS.length, consoleLogger.logger.levels.length);
+    });
+
+    it('should level from consoleLogger equal error', () => {
+      const consoleLogger = logger(LEVELS[0]);
+      assert.strictEqual(LEVELS[0], consoleLogger.logger.level);
+    });
+  });
+
+  /**
+   * 
+   */
+  describe('error logger', () => {
+    const consoleLogger = logger(LEVELS[0]);
+
+    it('should logger error in console', () => {
+      consoleTxt = '';
+      consoleLogger.error('error test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('error');
+
+      assert.ok(validateString >= 0);
+    });
+
+    it('should not logger warn in console', () => {
+      consoleTxt = '';
+      consoleLogger.warn('warn test logger in console');
+      unhookIntercept();
+
+      const validateString = consoleTxt.indexOf('warn');
+
+      assert.equal(validateString, -1);
+    });
+
+    it('should not logger info in console', () => {
+      consoleTxt = '';
+      consoleLogger.info('info test logger in console');
+      unhookIntercept();
+
+      const validateString = consoleTxt.indexOf('info');
+
+      assert.equal(validateString, -1);
+    });
+
+    it('should not logger debug in console', () => {
+      consoleTxt = '';
+      consoleLogger.debug('debug test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('debug');
+
+      assert.equal(validateString, -1);
+    });
+
+    it('should not logger silly in console', () => {
+      consoleTxt = '';
+      consoleLogger.silly('silly test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('silly');
+
+      assert.equal(validateString, -1);
+    });
+  });
+
+   describe('info logger', () => {
+     
+    const consoleLogger = logger(LEVELS[2]);
+
+    it('should logger error in console', () => {
+      const intercept = require('intercept-stdout');
+      const unhookIntercept = intercept((txt) => {
+        consoleTxt = txt;
+        return txt;
+      });
+  
+      consoleTxt = '';
+      consoleLogger.error('error test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('error');
+
+      assert.ok(validateString >= 0);
+    });
+
+    it('should not logger warn in console', () => {
+      const intercept = require('intercept-stdout');
+      const unhookIntercept = intercept((txt) => {
+        consoleTxt = txt;
+        return txt;
+      });
+  
+      consoleTxt = '';
+      consoleLogger.warn('warn test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('warn');
+
+      assert.ok(validateString >= 0);
+    });
+
+    it('should logger info in console', () => {
+      const intercept = require('intercept-stdout');
+      const unhookIntercept = intercept((txt) => {
+        consoleTxt = txt;
+        return txt;
+      });
+  
+      consoleTxt = '';
+      consoleLogger.info('info test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('info');
+
+      assert.ok(validateString >= 0);
+    });
+
+    it('should not logger debug in console', () => {
+      const intercept = require('intercept-stdout');
+      const unhookIntercept = intercept((txt) => {
+        consoleTxt = txt;
+        return txt;
+      });
+  
+      consoleTxt = '';
+      consoleLogger.debug('debug test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('debug');
+
+      assert.equal(validateString, -1);
+    });
+
+    it('should not logger silly in console', () => {
+      const intercept = require('intercept-stdout');
+      const unhookIntercept = intercept((txt) => {
+        consoleTxt = txt;
+        return txt;
       });
-});
+  
+      consoleTxt = '';
+      consoleLogger.silly('silly test logger in console');
+      unhookIntercept();
+      const validateString = consoleTxt.indexOf('silly');
 
+      assert.equal(validateString, -1);
+    });
+  });
+  
+});