adapt-authoring-core 2.5.0 → 3.0.1

package/tests/Logger.spec.js

@@ -0,0 +1,187 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import Logger from '../lib/Logger.js'
+
+describe('Logger', () => {
+  describe('constructor', () => {
+    it('should create with defaults', () => {
+      const logger = new Logger()
+      assert.ok(logger.config)
+      assert.ok(logger.logHook)
+      assert.equal(logger.config.mute, false)
+    })
+
+    it('should mute when levels is empty', () => {
+      const logger = new Logger({ levels: [] })
+      assert.equal(logger.config.mute, true)
+    })
+
+    it('should not mute when levels are provided', () => {
+      const logger = new Logger({ levels: ['error'] })
+      assert.equal(logger.config.mute, false)
+    })
+
+    it('should configure levels from options', () => {
+      const logger = new Logger({ levels: ['error', 'warn'] })
+      assert.equal(logger.config.levels.error.enable, true)
+      assert.equal(logger.config.levels.debug.enable, false)
+    })
+  })
+
+  describe('.isLevelEnabled()', () => {
+    it('should return true when level is in config', () => {
+      assert.equal(Logger.isLevelEnabled(['error', 'warn'], 'error'), true)
+    })
+
+    it('should return false when level is not in config', () => {
+      assert.equal(Logger.isLevelEnabled(['error'], 'debug'), false)
+    })
+
+    it('should return false when level is negated', () => {
+      assert.equal(Logger.isLevelEnabled(['error', '!error'], 'error'), false)
+    })
+  })
+
+  describe('.getModuleOverrides()', () => {
+    it('should return matching overrides', () => {
+      const config = ['error', 'debug.mymod', '!debug.other']
+      assert.deepEqual(Logger.getModuleOverrides(config, 'debug'), ['debug.mymod', '!debug.other'])
+    })
+
+    it('should return empty array when no overrides', () => {
+      assert.deepEqual(Logger.getModuleOverrides(['error'], 'debug'), [])
+    })
+
+    it('should not include line-level (3-segment) entries', () => {
+      const config = ['debug.mymod', 'debug.mymod.LOAD', '!debug.other.SAVE']
+      assert.deepEqual(Logger.getModuleOverrides(config, 'debug'), ['debug.mymod'])
+    })
+
+    it('should not include id-wide entries', () => {
+      const config = ['debug.mymod', 'mymod', '!other']
+      assert.deepEqual(Logger.getModuleOverrides(config, 'debug'), ['debug.mymod'])
+    })
+  })
+
+  describe('.getLineOverrides()', () => {
+    it('should return only 3-segment entries for the level', () => {
+      const config = ['debug', 'debug.mymod', 'debug.mymod.LOAD', '!debug.other.SAVE', 'verbose.foo.BAR']
+      assert.deepEqual(Logger.getLineOverrides(config, 'debug'), ['debug.mymod.LOAD', '!debug.other.SAVE'])
+    })
+
+    it('should return empty array when no line overrides', () => {
+      assert.deepEqual(Logger.getLineOverrides(['debug', 'debug.mymod'], 'debug'), [])
+    })
+  })
+
+  describe('.getIdOverrides()', () => {
+    it('should return entries whose first segment is not a known level', () => {
+      const config = ['debug', 'debug.mymod', 'mymod', '!other', 'datacache']
+      assert.deepEqual(Logger.getIdOverrides(config), ['mymod', '!other', 'datacache'])
+    })
+
+    it('should not include bare level entries', () => {
+      assert.deepEqual(Logger.getIdOverrides(['debug', '!verbose']), [])
+    })
+
+    it('should not include level-prefixed entries', () => {
+      assert.deepEqual(Logger.getIdOverrides(['debug.mymod', '!verbose.foo.BAR']), [])
+    })
+  })
+
+  describe('.isLoggingEnabled()', () => {
+    it('should return true when level is enabled', () => {
+      const levels = { error: { enable: true, moduleOverrides: [] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'error', 'test'), true)
+    })
+
+    it('should return false when level is disabled', () => {
+      const levels = { error: { enable: false, moduleOverrides: [] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'error', 'test'), false)
+    })
+
+    it('should allow module-specific override', () => {
+      const levels = { debug: { enable: false, moduleOverrides: ['debug.mymod'] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'debug', 'mymod'), true)
+    })
+
+    it('should allow module-specific disable override', () => {
+      const levels = { debug: { enable: true, moduleOverrides: ['!debug.mymod'] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'debug', 'mymod'), false)
+    })
+
+    it('should mute a specific line via line-level override', () => {
+      const levels = { verbose: { enable: true, moduleOverrides: [], lineOverrides: ['!verbose.server.REQUEST_DURATION'] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'server', 'REQUEST_DURATION'), false)
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'server', 'ADD_ROUTE'), true)
+    })
+
+    it('should enable a specific line when level is otherwise disabled', () => {
+      const levels = { verbose: { enable: false, moduleOverrides: [], lineOverrides: ['verbose.server.ADD_ROUTE'] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'server', 'ADD_ROUTE'), true)
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'server', 'OTHER'), false)
+    })
+
+    it('should let line-level mute beat per-level module enable', () => {
+      const levels = { verbose: { enable: true, moduleOverrides: ['verbose.server'], lineOverrides: ['!verbose.server.REQUEST_DURATION'] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'server', 'REQUEST_DURATION'), false)
+    })
+
+    it('should mute via id-wide override at any level', () => {
+      const levels = { verbose: { enable: true, moduleOverrides: [], lineOverrides: [] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'datacache', undefined, ['!datacache']), false)
+    })
+
+    it('should let per-level module enable beat id-wide mute', () => {
+      const levels = { verbose: { enable: false, moduleOverrides: ['verbose.datacache'], lineOverrides: [] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'datacache', undefined, ['!datacache']), true)
+    })
+
+    it('should let id-wide enable beat global level mute', () => {
+      const levels = { verbose: { enable: false, moduleOverrides: [], lineOverrides: [] } }
+      assert.equal(Logger.isLoggingEnabled(levels, 'verbose', 'datacache', undefined, ['datacache']), true)
+    })
+  })
+
+  describe('#log()', () => {
+    it('should not throw when muted via empty levels', () => {
+      const logger = new Logger({ levels: [] })
+      assert.doesNotThrow(() => logger.log('error', 'test', 'message'))
+    })
+
+    it('should mute a specific line via config', () => {
+      const calls = []
+      const origInfo = console.info
+      console.info = (...args) => calls.push(args)
+      try {
+        const logger = new Logger({ levels: ['info', '!info.server.REQUEST_DURATION'], showTimestamp: false })
+        logger.log('info', 'server', 'REQUEST_DURATION', 'GET', '/foo')
+        logger.log('info', 'server', 'ADD_ROUTE', 'GET', '/foo')
+        assert.equal(calls.length, 1)
+        assert.match(calls[0].join(' '), /ADD_ROUTE/)
+      } finally {
+        console.info = origInfo
+      }
+    })
+
+    it('should mute an id at every level via config', () => {
+      const calls = []
+      const origInfo = console.info
+      const origWarn = console.warn
+      console.info = (...args) => calls.push(['info', args])
+      console.warn = (...args) => calls.push(['warn', args])
+      try {
+        const logger = new Logger({ levels: ['info', 'warn', '!datacache'], showTimestamp: false })
+        logger.log('info', 'datacache', 'hit')
+        logger.log('warn', 'datacache', 'miss')
+        logger.log('info', 'server', 'ok')
+        assert.equal(calls.length, 1)
+        assert.equal(calls[0][0], 'info')
+        assert.match(calls[0][1].join(' '), /server/)
+      } finally {
+        console.info = origInfo
+        console.warn = origWarn
+      }
+    })
+  })
+})

package/tests/utils-getArgs.spec.js

@@ -7,16 +7,10 @@ describe('getArgs()', () => {
   it('should return an object with parsed arguments', () => {
     const args = getArgs()
     assert.equal(typeof args, 'object')
-    assert.ok(Array.isArray(args.params))
   })
 
-  it('should include the underscore array from minimist', () => {
+  it('should include params as an array', () => {
     const args = getArgs()
-    assert.ok(Array.isArray(args._))
-  })
-
-  it('should derive params by slicing first two entries from _', () => {
-    const args = getArgs()
-    assert.deepEqual(args.params, args._.slice(2))
+    assert.ok(Array.isArray(args.params))
   })
 })

package/tests/App.spec.js

@@ -1,160 +0,0 @@
-import { describe, it, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import fs from 'fs-extra'
-import path from 'path'
-import { fileURLToPath } from 'url'
-import App from '../lib/App.js'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-
-describe('App', () => {
-  let testRootDir
-  let originalRootDir
-
-  before(async () => {
-    testRootDir = path.join(__dirname, 'data', 'app-test')
-    await fs.ensureDir(testRootDir)
-    await fs.writeJson(path.join(testRootDir, 'package.json'), {
-      name: 'test-app',
-      version: '1.0.0'
-    })
-    await fs.writeJson(path.join(testRootDir, 'adapt-authoring.json'), {
-      essentialApis: []
-    })
-    originalRootDir = process.env.ROOT_DIR
-    process.env.ROOT_DIR = testRootDir
-  })
-
-  after(async () => {
-    if (originalRootDir !== undefined) {
-      process.env.ROOT_DIR = originalRootDir
-    } else {
-      delete process.env.ROOT_DIR
-    }
-    await fs.remove(testRootDir)
-  })
-
-  describe('.instance', () => {
-    it('should return an App instance', () => {
-      const app = App.instance
-      assert.ok(app instanceof App)
-    })
-
-    it('should return the same instance on subsequent calls (singleton)', () => {
-      const app1 = App.instance
-      const app2 = App.instance
-      assert.equal(app1, app2)
-    })
-  })
-
-  describe('constructor', () => {
-    it('should set name to adapt-authoring-core', () => {
-      const app = App.instance
-      assert.equal(app.name, 'adapt-authoring-core')
-    })
-
-    it('should set rootDir from ROOT_DIR env var', () => {
-      const app = App.instance
-      assert.equal(app.rootDir, testRootDir)
-    })
-
-    it('should initialize git info', () => {
-      const app = App.instance
-      assert.equal(typeof app.git, 'object')
-    })
-  })
-
-  describe('#dependencies', () => {
-    it('should return the dependency configs from dependencyloader', () => {
-      const app = App.instance
-      assert.equal(typeof app.dependencies, 'object')
-      assert.equal(app.dependencies, app.dependencyloader.configs)
-    })
-  })
-
-  describe('#getGitInfo()', () => {
-    it('should return an object', () => {
-      const app = App.instance
-      const info = app.getGitInfo()
-      assert.equal(typeof info, 'object')
-    })
-
-    it('should return empty object when .git directory does not exist', () => {
-      const app = App.instance
-      const origRootDir = app.rootDir
-      app.rootDir = '/nonexistent/path'
-      const info = app.getGitInfo()
-      app.rootDir = origRootDir
-      assert.deepEqual(info, {})
-    })
-
-    it('should return object with branch and commit when .git exists', async () => {
-      const gitDir = path.join(testRootDir, '.git')
-      const refsDir = path.join(gitDir, 'refs', 'heads')
-      await fs.ensureDir(refsDir)
-      await fs.writeFile(path.join(gitDir, 'HEAD'), 'ref: refs/heads/main\n')
-      await fs.writeFile(path.join(refsDir, 'main'), 'abc123def456\n')
-
-      const app = App.instance
-      const origRootDir = app.rootDir
-      app.rootDir = testRootDir
-      const info = app.getGitInfo()
-      app.rootDir = origRootDir
-
-      assert.equal(info.branch, 'main')
-      assert.equal(info.commit, 'abc123def456')
-
-      await fs.remove(gitDir)
-    })
-  })
-
-  describe('#waitForModule()', () => {
-    it('should delegate to dependencyloader.waitForModule', async () => {
-      const app = App.instance
-      let calledWith
-      const origWaitForModule = app.dependencyloader.waitForModule.bind(app.dependencyloader)
-      app.dependencyloader.waitForModule = async (name) => {
-        calledWith = name
-        return { name }
-      }
-      const result = await app.waitForModule('test-mod')
-      app.dependencyloader.waitForModule = origWaitForModule
-
-      assert.equal(calledWith, 'test-mod')
-      assert.deepEqual(result, { name: 'test-mod' })
-    })
-
-    it('should return array when multiple module names are passed', async () => {
-      const app = App.instance
-      const origWaitForModule = app.dependencyloader.waitForModule.bind(app.dependencyloader)
-      app.dependencyloader.waitForModule = async (name) => ({ name })
-      const result = await app.waitForModule('mod-a', 'mod-b')
-      app.dependencyloader.waitForModule = origWaitForModule
-
-      assert.ok(Array.isArray(result))
-      assert.equal(result.length, 2)
-      assert.deepEqual(result[0], { name: 'mod-a' })
-      assert.deepEqual(result[1], { name: 'mod-b' })
-    })
-
-    it('should return single result (not array) for single module', async () => {
-      const app = App.instance
-      const origWaitForModule = app.dependencyloader.waitForModule.bind(app.dependencyloader)
-      app.dependencyloader.waitForModule = async (name) => ({ name })
-      const result = await app.waitForModule('single-mod')
-      app.dependencyloader.waitForModule = origWaitForModule
-
-      assert.ok(!Array.isArray(result))
-      assert.deepEqual(result, { name: 'single-mod' })
-    })
-  })
-
-  describe('#setReady()', () => {
-    it('should set _isStarting to false', async () => {
-      const app = App.instance
-      app._isStarting = true
-      await app.setReady()
-      assert.equal(app._isStarting, false)
-    })
-  })
-})