refactor: create distinct log methods

Author: drazisil-codecov

src/helpers/logger.js

@@ -1,7 +1,21 @@
 // @ts-check
 
 /**
- *
+ *  We really only need three log levels
+ * * Error
+ * * Info
+ * * Verbose
+ * For the purposes of minimal refactor, I'm aliasing debug() to verbose()
+ * I'm also mapping the log() options to the new calls and
+ * deprecating log()
+ */
+
+function _getTimestamp() {
+  return new Date().toISOString()
+}
+
+/**
+ * @deprecated - Please use error(), info(), or verbose()
  * @param {string} message
  * @param {Object} [options]
  * @param {string} [options.level]
@@ -11,24 +25,56 @@
  */
 function log(message, options) {
   if (!options || !options.level) {
-    return console.log(message)
+    return info(message)
   }
   switch (options.level) {
     case 'debug':
       if (options.args && options.args.verbose) {
-        console.debug(message)
+        return verbose(message, true)
       }
 
       break
     case 'error':
-      console.error(message)
-      break
+      return error(message)
     default:
-      console.log(message)
-      break
+      return info(message)
+  }
+}
+
+/**
+ *
+ * @param {string} message - message to log
+ * @param {boolean} shouldVerbose - pass the value of the verbose flag
+ * @return void
+ */
+function verbose(message, shouldVerbose = false) {
+  if (shouldVerbose === true) {
+    console.debug(`[${_getTimestamp()}] ['verbose'] ${message}`)
   }
 }
 
+/**
+ *
+ * @param {string} message - message to log
+ * @return void
+ */
+function error(message) {
+  console.error(`[${_getTimestamp()}] ['error'] ${message}`)
+}
+
+/**
+ *
+ * @param {string} message - message to log
+ * @return void
+ */
+function info(message) {
+  console.log(`[${_getTimestamp()}] ['info'] ${message}`)
+}
+
 module.exports = {
+  debug: verbose,
+  error,
+  info,
   log,
+  verbose,
 }

test/helpers/logger.test.js

@@ -1,16 +1,16 @@
 // @ts-check
-const logger = require('../../src/helpers/logger')
+const { error, info, verbose, log } = require('../../src/helpers/logger')
 const { expect, it } = require('@jest/globals')
 
-describe('Logger Helper', () => {
+describe('Logger Helper - Legacy log() tests', () => {
   afterEach(() => {
-    jest.restoreAllMocks()
+    jest.clearAllMocks()
   })
 
   it('Should call logger with default options', () => {
     // eslint-disable-next-line
     jest.spyOn(console, 'log').mockImplementation(() => {})
-    logger.log('message with no options')
+    log('message with no options')
     expect(console.log).toHaveBeenCalledWith(
       expect.stringMatching(/no options/),
     )
@@ -19,15 +19,15 @@ describe('Logger Helper', () => {
   it('Should not call logger with default options.level = debug and verbose not set', () => {
     // eslint-disable-next-line
     jest.spyOn(console, 'debug').mockImplementation(() => {})
-    logger.log('message with debug level', { level: 'debug' })
+    log('message with debug level', { level: 'debug' })
     expect(console.debug).not.toHaveBeenCalled()
   })
 
   it('Should call logger with options.level = debug and verbose set', () => {
     jest.spyOn(console, 'debug').mockImplementation(() => {
       // Intentionally empty
     })
-    logger.log('message with debug level and verbose', {
+    log('message with debug level and verbose', {
       level: 'debug',
       args: { verbose: true },
     })
@@ -40,7 +40,7 @@ describe('Logger Helper', () => {
     jest.spyOn(console, 'error').mockImplementation(() => {
       // Intentionally empty
     })
-    logger.log('message with error level', { level: 'error' })
+    log('message with error level', { level: 'error' })
     expect(console.error).toHaveBeenCalledWith(
       expect.stringMatching(/error level/),
     )
@@ -50,7 +50,63 @@ describe('Logger Helper', () => {
     jest.spyOn(console, 'log').mockImplementation(() => {
       // Intentionally empty
     })
-    logger.log('message with error level of foobar', { level: 'foobar' })
+    log('message with error level of foobar', { level: 'foobar' })
     expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/of foobar/))
   })
 })
+
+describe('Logging methods', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should call console.error() when error() is called', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {
+      // Intentionally empty
+    })
+    error('this is a test error')
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/\['error'\]/),
+    )
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringMatching(/this is a test error/),
+    )
+    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/Z\]/))
+  })
+
+  it('should call console.debug() when verbose() is called with shouldVerbose === true', () => {
+    jest.spyOn(console, 'debug').mockImplementation(() => {
+      // Intentionally empty
+    })
+    verbose('this is a test verbose', true)
+    expect(console.debug).toHaveBeenCalledWith(
+      expect.stringMatching(/\['verbose'\]/),
+    )
+    expect(console.debug).toHaveBeenCalledWith(
+      expect.stringMatching(/this is a test verbose/),
+    )
+    expect(console.debug).toHaveBeenCalledWith(expect.stringMatching(/Z\]/))
+  })
+
+  it('should not call console.debug() when verbose() is called without shouldVerbose', () => {
+    jest.spyOn(console, 'debug').mockImplementation(() => {
+      // Intentionally empty
+    })
+    verbose('this is a test verbose')
+    expect(console.debug).not.toBeCalled()
+  })
+
+  it('should call console.log() when info() is called ', () => {
+    jest.spyOn(console, 'log').mockImplementation(() => {
+      // Intentionally empty
+    })
+    info('this is a test info')
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringMatching(/\['info'\]/),
+    )
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringMatching(/this is a test info/),
+    )
+    expect(console.log).toHaveBeenCalledWith(expect.stringMatching(/Z\]/))
+  })
+})