adapt-authoring-logger 1.1.2 → 1.2.0

package/.github/workflows/tests.yml

@@ -1,8 +1,10 @@
-name: Run test scripts
+name: Tests
 on: push
 jobs:
   default:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - uses: actions/checkout@master
       - uses: actions/setup-node@master

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-logger",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Basic logger for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-logger",
   "license": "GPL-3.0",
@@ -8,10 +8,16 @@
   "main": "index.js",
   "repository": "adapt-security/adapt-authoring-logger",
   "dependencies": {
+    "adapt-authoring-core": "^1.7.0",
     "chalk": "^5.3.0"
   },
   "peerDependencies": {
-    "adapt-authoring-core": "^1.0.0"
+    "adapt-authoring-config": "^1.1.4"
+  },
+  "peerDependenciesMeta": {
+    "adapt-authoring-config": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@semantic-release/git": "^10.0.1",
@@ -35,10 +41,18 @@
       ],
       "@semantic-release/npm",
       "@semantic-release/github",
-      "@semantic-release/git"
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json"
+          ],
+          "message": "Chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
     ]
   },
   "scripts": {
-    "test": "node --test"
+    "test": "node --test tests/*.spec.js"
   }
 }

package/{test/LoggerModule.test.js → tests/LoggerModule.spec.js}

@@ -1,10 +1,11 @@
-import assert from 'assert'
 import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
 import chalk from 'chalk'
+import { AbstractModule } from 'adapt-authoring-core'
 import LoggerModule from '../lib/LoggerModule.js'
 
 describe('LoggerModule', () => {
-  describe('colourise()', () => {
+  describe('#colourise()', () => {
     it('should return string with colour function applied', () => {
       const result = LoggerModule.colourise('test', chalk.red)
       assert.ok(result.includes('test'))
@@ -17,20 +18,30 @@ describe('LoggerModule', () => {
 
     it('should return uncoloured string if no colour function provided', () => {
       const result = LoggerModule.colourise('test', null)
-      assert.strictEqual(result, 'test')
+      assert.equal(result, 'test')
     })
 
     it('should handle undefined colour function', () => {
       const result = LoggerModule.colourise('test', undefined)
-      assert.strictEqual(result, 'test')
+      assert.equal(result, 'test')
+    })
+
+    it('should return empty string unchanged when no colour', () => {
+      const result = LoggerModule.colourise('', null)
+      assert.equal(result, '')
+    })
+
+    it('should apply colour function to empty string', () => {
+      const result = LoggerModule.colourise('', chalk.red)
+      assert.equal(typeof result, 'string')
     })
   })
 
-  describe('getDateStamp()', () => {
+  describe('#getDateStamp()', () => {
     it('should return empty string when timestamp is disabled', () => {
       const config = { timestamp: false }
       const result = LoggerModule.getDateStamp(config)
-      assert.strictEqual(result, '')
+      assert.equal(result, '')
     })
 
     it('should return ISO format date when dateFormat is "iso"', () => {
@@ -42,11 +53,23 @@ describe('LoggerModule', () => {
     it('should return short format date when dateFormat is "short"', () => {
       const config = { timestamp: true, dateFormat: 'short' }
       const result = LoggerModule.getDateStamp(config)
-      assert.ok(/\d{1,2}\/\d{2}\/\d{2}-\d{2}:\d{2}:\d{2}/.test(result))
+      assert.ok(/\d{1,2}\/\d{2}\/\d{2}-\d{1,2}:\d{1,2}:\d{2}/.test(result))
+    })
+
+    it('should return undefined-based string for unrecognised dateFormat', () => {
+      const config = { timestamp: true, dateFormat: 'unknown' }
+      const result = LoggerModule.getDateStamp(config)
+      assert.ok(result.includes('undefined'))
+    })
+
+    it('should include trailing space in formatted timestamp', () => {
+      const config = { timestamp: true, dateFormat: 'iso' }
+      const result = LoggerModule.getDateStamp(config)
+      assert.ok(result.includes(' '))
     })
   })
 
-  describe('isLevelEnabled()', () => {
+  describe('#isLevelEnabled()', () => {
     let logger
 
     beforeEach(() => {
@@ -55,28 +78,39 @@ describe('LoggerModule', () => {
     })
 
     it('should return true for enabled levels', () => {
-      assert.strictEqual(logger.isLevelEnabled('error'), true)
-      assert.strictEqual(logger.isLevelEnabled('warn'), true)
-      assert.strictEqual(logger.isLevelEnabled('info'), true)
+      assert.equal(logger.isLevelEnabled('error'), true)
+      assert.equal(logger.isLevelEnabled('warn'), true)
+      assert.equal(logger.isLevelEnabled('info'), true)
     })
 
     it('should return false for disabled levels', () => {
-      assert.strictEqual(logger.isLevelEnabled('debug'), false)
-      assert.strictEqual(logger.isLevelEnabled('verbose'), false)
+      assert.equal(logger.isLevelEnabled('debug'), false)
+      assert.equal(logger.isLevelEnabled('verbose'), false)
     })
 
     it('should return false when level is explicitly disabled', () => {
       logger.levelsConfig = ['error', '!warn', 'info']
-      assert.strictEqual(logger.isLevelEnabled('warn'), false)
+      assert.equal(logger.isLevelEnabled('warn'), false)
     })
 
     it('should give preference to explicit disable', () => {
       logger.levelsConfig = ['warn', '!warn']
-      assert.strictEqual(logger.isLevelEnabled('warn'), false)
+      assert.equal(logger.isLevelEnabled('warn'), false)
+    })
+
+    it('should return false for empty levelsConfig', () => {
+      logger.levelsConfig = []
+      assert.equal(logger.isLevelEnabled('error'), false)
+    })
+
+    it('should not match partial level names', () => {
+      logger.levelsConfig = ['info']
+      assert.equal(logger.isLevelEnabled('inf'), false)
+      assert.equal(logger.isLevelEnabled('information'), false)
     })
   })
 
-  describe('getModuleOverrides()', () => {
+  describe('#getModuleOverrides()', () => {
     let logger
 
     beforeEach(() => {
@@ -88,7 +122,7 @@ describe('LoggerModule', () => {
       const result = logger.getModuleOverrides('error')
       assert.ok(result.includes('error.myModule'))
       assert.ok(result.includes('error.anotherModule'))
-      assert.strictEqual(result.length, 2)
+      assert.equal(result.length, 2)
     })
 
     it('should include negative overrides', () => {
@@ -100,7 +134,7 @@ describe('LoggerModule', () => {
     it('should return empty array when no overrides exist', () => {
       logger.levelsConfig = ['error', 'warn']
       const result = logger.getModuleOverrides('info')
-      assert.strictEqual(result.length, 0)
+      assert.equal(result.length, 0)
     })
 
     it('should not include overrides for other levels', () => {
@@ -108,9 +142,23 @@ describe('LoggerModule', () => {
       const result = logger.getModuleOverrides('error')
       assert.ok(!result.includes('warn.moduleB'))
     })
+
+    it('should return both positive and negative overrides together', () => {
+      logger.levelsConfig = ['error', 'error.modA', '!error.modB']
+      const result = logger.getModuleOverrides('error')
+      assert.equal(result.length, 2)
+      assert.ok(result.includes('error.modA'))
+      assert.ok(result.includes('!error.modB'))
+    })
+
+    it('should return empty array for empty levelsConfig', () => {
+      logger.levelsConfig = []
+      const result = logger.getModuleOverrides('error')
+      assert.deepEqual(result, [])
+    })
   })
 
-  describe('isLoggingEnabled()', () => {
+  describe('#isLoggingEnabled()', () => {
     let logger
 
     beforeEach(() => {
@@ -125,31 +173,54 @@ describe('LoggerModule', () => {
     })
 
     it('should return true for enabled levels', () => {
-      assert.strictEqual(logger.isLoggingEnabled('error', 'anyId'), true)
+      assert.equal(logger.isLoggingEnabled('error', 'anyId'), true)
     })
 
     it('should return false for disabled levels without overrides', () => {
-      assert.strictEqual(logger.isLoggingEnabled('warn', 'generic'), false)
+      assert.equal(logger.isLoggingEnabled('warn', 'generic'), false)
     })
 
     it('should return true for disabled level with positive override', () => {
-      assert.strictEqual(logger.isLoggingEnabled('warn', 'specific'), true)
+      assert.equal(logger.isLoggingEnabled('warn', 'specific'), true)
     })
 
     it('should return false for enabled level with negative override', () => {
-      assert.strictEqual(logger.isLoggingEnabled('info', 'blocked'), false)
+      assert.equal(logger.isLoggingEnabled('info', 'blocked'), false)
     })
 
     it('should return true for enabled level without override', () => {
-      assert.strictEqual(logger.isLoggingEnabled('info', 'allowed'), true)
+      assert.equal(logger.isLoggingEnabled('info', 'allowed'), true)
     })
 
     it('should handle missing level config gracefully', () => {
-      assert.strictEqual(logger.isLoggingEnabled('nonexistent', 'id'), false)
+      assert.equal(logger.isLoggingEnabled('nonexistent', 'id'), false)
+    })
+
+    it('should default moduleOverrides to empty array when undefined', () => {
+      logger.config = {
+        levels: {
+          error: { enable: true }
+        }
+      }
+      assert.equal(logger.isLoggingEnabled('error', 'anyId'), true)
+    })
+
+    it('should return false when both enable is false and no matching override', () => {
+      logger.config = {
+        levels: {
+          debug: { enable: false, moduleOverrides: ['debug.other'] }
+        }
+      }
+      assert.equal(logger.isLoggingEnabled('debug', 'notOther'), false)
+    })
+
+    it('should handle config being undefined gracefully', () => {
+      logger.config = undefined
+      assert.equal(logger.isLoggingEnabled('error', 'id'), false)
     })
   })
 
-  describe('log()', () => {
+  describe('#log()', () => {
     let logger
     let logOutput
     let originalConsoleLog
@@ -184,24 +255,24 @@ describe('LoggerModule', () => {
     it('should not log when muted', () => {
       logger.config.mute = true
       logger.log('info', 'test', 'message')
-      assert.strictEqual(logOutput.length, 0)
+      assert.equal(logOutput.length, 0)
     })
 
     it('should not log when level is disabled', () => {
       logger.config.levels.debug.enable = false
       logger.log('debug', 'test', 'message')
-      assert.strictEqual(logOutput.length, 0)
+      assert.equal(logOutput.length, 0)
     })
 
     it('should log message when enabled', () => {
       logger.log('info', 'testId', 'test message')
-      assert.strictEqual(logOutput.length, 1)
+      assert.equal(logOutput.length, 1)
       assert.ok(logOutput[0].args.some(arg => typeof arg === 'string' && arg.includes('testId')))
     })
 
     it('should include multiple arguments', () => {
       logger.log('info', 'test', 'arg1', 'arg2', 'arg3')
-      assert.strictEqual(logOutput.length, 1)
+      assert.equal(logOutput.length, 1)
       const args = logOutput[0].args
       assert.ok(args.includes('arg1'))
       assert.ok(args.includes('arg2'))
@@ -210,7 +281,7 @@ describe('LoggerModule', () => {
 
     it('should use correct console method for level', () => {
       logger.log('error', 'test', 'message')
-      assert.strictEqual(logOutput[0].level, 'error')
+      assert.equal(logOutput[0].level, 'error')
     })
 
     it('should invoke logHook with correct parameters', () => {
@@ -220,21 +291,73 @@ describe('LoggerModule', () => {
       }
       logger.log('info', 'testId', 'message')
       assert.ok(hookArgs)
-      assert.strictEqual(hookArgs[1], 'info')
-      assert.strictEqual(hookArgs[2], 'testId')
-      assert.strictEqual(hookArgs[3], 'message')
+      assert.equal(hookArgs[1], 'info')
+      assert.equal(hookArgs[2], 'testId')
+      assert.equal(hookArgs[3], 'message')
     })
 
     it('should colorise level in output', () => {
       logger.log('info', 'test', 'message')
-      assert.strictEqual(logOutput.length, 1)
+      assert.equal(logOutput.length, 1)
       assert.ok(logOutput[0].args[0].includes('info'))
     })
 
     it('should colorise id in output', () => {
       logger.log('info', 'myModule', 'message')
-      assert.strictEqual(logOutput.length, 1)
+      assert.equal(logOutput.length, 1)
       assert.ok(logOutput[0].args[0].includes('myModule'))
     })
+
+    it('should treat string "true" mute value as muted', () => {
+      logger.config.mute = 'true'
+      logger.log('info', 'test', 'message')
+      assert.equal(logOutput.length, 0)
+    })
+
+    it('should not mute when mute is "false"', () => {
+      logger.config.mute = 'false'
+      logger.log('info', 'test', 'message')
+      assert.equal(logOutput.length, 1)
+    })
+
+    it('should fall back to console.log for unknown level', () => {
+      logger.config.levels.success = { enable: true, moduleOverrides: [], colour: chalk.green }
+      logger.log('success', 'test', 'message')
+      assert.equal(logOutput.length, 1)
+      assert.equal(logOutput[0].level, 'log')
+    })
+
+    it('should handle MODULE_READY id by using module name suffix', () => {
+      logger.name = 'adapt-authoring-logger'
+      logger.config.levels.verbose = { enable: true, moduleOverrides: [], colour: chalk.grey }
+      let hookArgs = null
+      logger.logHook.invoke = (...args) => { hookArgs = args }
+      logger.log('verbose', AbstractModule.MODULE_READY, 'some-init-time')
+      assert.equal(logOutput.length, 1)
+      assert.ok(logOutput[0].args[0].includes('logger'))
+      assert.equal(hookArgs[2], 'logger')
+      assert.equal(hookArgs[3], AbstractModule.MODULE_READY)
+      assert.equal(hookArgs[4], 'some-init-time')
+    })
+
+    it('should prepend date stamp when timestamp is enabled', () => {
+      logger.config.timestamp = true
+      logger.config.dateFormat = 'iso'
+      logger.log('info', 'test', 'message')
+      assert.equal(logOutput.length, 1)
+      assert.ok(/\d{4}-\d{2}-\d{2}T/.test(logOutput[0].args[0]))
+    })
+
+    it('should pass Date as first argument to logHook', () => {
+      let hookArgs = null
+      logger.logHook.invoke = (...args) => { hookArgs = args }
+      logger.log('info', 'test', 'message')
+      assert.ok(hookArgs[0] instanceof Date)
+    })
+
+    it('should handle config being undefined gracefully', () => {
+      logger.config = undefined
+      assert.doesNotThrow(() => logger.log('info', 'test', 'message'))
+    })
   })
 })