adapt-authoring-core 2.5.0 → 3.0.1

package/tests/DataCache.spec.js

@@ -1,7 +1,20 @@
-import { describe, it } from 'node:test'
+import { afterEach, beforeEach, describe, it } from 'node:test'
 import assert from 'node:assert/strict'
+import App from '../lib/App.js'
 import DataCache from '../lib/DataCache.js'
 
+function stubApp (mongodbStub, logCalls) {
+  const mockApp = {
+    waitForModule: async () => mongodbStub,
+    logger: {
+      log: (...args) => logCalls.push(args)
+    }
+  }
+  const original = Object.getOwnPropertyDescriptor(App, 'instance')
+  Object.defineProperty(App, 'instance', { get: () => mockApp, configurable: true })
+  return () => Object.defineProperty(App, 'instance', original)
+}
+
 describe('DataCache', () => {
   describe('#prune()', () => {
     it('should remove expired entries from the cache', () => {
@@ -36,4 +49,74 @@ describe('DataCache', () => {
       assert.deepEqual(instance.cache, {})
     })
   })
+
+  describe('#get()', () => {
+    let findCalls
+    let logCalls
+    let restore
+    const mongoStub = {
+      find: async (...args) => {
+        findCalls.push(args)
+        return [{ _id: 'stub' }]
+      }
+    }
+
+    beforeEach(() => {
+      findCalls = []
+      logCalls = []
+      restore = stubApp(mongoStub, logCalls)
+    })
+
+    afterEach(() => restore())
+
+    it('should query the DB and log a miss on first call', async () => {
+      const cache = new DataCache({ enable: true, lifespan: 10000 })
+      const result = await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      assert.deepEqual(result, [{ _id: 'stub' }])
+      assert.equal(findCalls.length, 1)
+      assert.equal(cache.misses, 1)
+      assert.equal(cache.hits, 0)
+      assert.equal(logCalls[0][0], 'verbose')
+      assert.equal(logCalls[0][1], 'datacache')
+      assert.equal(logCalls[0][2], 'miss')
+    })
+
+    it('should return cached data and log a hit on a repeat call', async () => {
+      const cache = new DataCache({ enable: true, lifespan: 10000 })
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      assert.equal(findCalls.length, 1)
+      assert.equal(cache.hits, 1)
+      assert.equal(cache.misses, 1)
+      assert.equal(logCalls[1][2], 'hit')
+    })
+
+    it('should re-query the DB after an entry expires', async () => {
+      const cache = new DataCache({ enable: true, lifespan: 10 })
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      await new Promise(resolve => setTimeout(resolve, 20))
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      assert.equal(findCalls.length, 2)
+      assert.equal(cache.hits, 0)
+      assert.equal(cache.misses, 2)
+    })
+
+    it('should always query the DB when the cache is disabled', async () => {
+      const cache = new DataCache({ enable: false, lifespan: 10000 })
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      assert.equal(findCalls.length, 2)
+      assert.equal(cache.hits, 0)
+      assert.equal(cache.misses, 2)
+    })
+
+    it('should treat different queries as distinct cache entries', async () => {
+      const cache = new DataCache({ enable: true, lifespan: 10000 })
+      await cache.get({ _id: '1' }, { collectionName: 'users' }, {})
+      await cache.get({ _id: '2' }, { collectionName: 'users' }, {})
+      assert.equal(findCalls.length, 2)
+      assert.equal(cache.misses, 2)
+      assert.equal(cache.hits, 0)
+    })
+  })
 })

package/tests/DependencyLoader.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, before, after } from 'node:test'
 import assert from 'node:assert/strict'
+import AdaptError from '../lib/AdaptError.js'
 import DependencyLoader from '../lib/DependencyLoader.js'
 import fs from 'fs-extra'
 import path from 'path'
@@ -62,12 +63,11 @@ describe('DependencyLoader', () => {
       })
     })
 
-    it('should call app.logger when available and ready', () => {
+    it('should call app.logger when available', () => {
       let logged = false
       const mockApp = {
         rootDir: '/test',
         logger: {
-          _isReady: true, // Note: Mock uses private property to simulate ready state
           log: () => { logged = true }
         }
       }
@@ -78,27 +78,11 @@ describe('DependencyLoader', () => {
       assert.equal(logged, true)
     })
 
-    it('should fall back to console.log when logger not ready', () => {
-      const mockApp = {
-        rootDir: '/test',
-        logger: {
-          _isReady: false, // Note: Mock uses private property to check ready state
-          log: () => {}
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-
-      assert.doesNotThrow(() => {
-        loader.log('info', 'test message')
-      })
-    })
-
     it('should pass level and args to app.logger.log', () => {
       let loggedLevel, loggedName, loggedArgs
       const mockApp = {
         rootDir: '/test',
         logger: {
-          _isReady: true,
           log: (level, name, ...args) => {
             loggedLevel = level
             loggedName = name
@@ -115,97 +99,6 @@ describe('DependencyLoader', () => {
     })
   })
 
-  describe('#logError()', () => {
-    it('should call log with error level', () => {
-      let loggedLevel
-      const mockApp = {
-        rootDir: '/test',
-        logger: {
-          _isReady: true,
-          log: (level) => { loggedLevel = level }
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-
-      loader.logError('error message')
-
-      assert.equal(loggedLevel, 'error')
-    })
-
-    it('should pass all arguments through to log', () => {
-      let loggedArgs
-      const mockApp = {
-        rootDir: '/test',
-        logger: {
-          _isReady: true,
-          log: (level, name, ...args) => { loggedArgs = args }
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-      loader.logError('msg1', 'msg2')
-      assert.deepEqual(loggedArgs, ['msg1', 'msg2'])
-    })
-  })
-
-  describe('#getConfig()', () => {
-    it('should return undefined when config is not ready', () => {
-      const mockApp = {
-        rootDir: '/test'
-      }
-      const loader = new DependencyLoader(mockApp)
-
-      const result = loader.getConfig('someKey')
-
-      assert.equal(result, undefined)
-    })
-
-    it('should return config value when config is ready', () => {
-      const mockApp = {
-        rootDir: '/test',
-        config: {
-          _isReady: true, // Note: Mock uses private property to simulate ready state
-          get: (key) => {
-            if (key === 'adapt-authoring-core.testKey') return 'testValue'
-          }
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-
-      const result = loader.getConfig('testKey')
-
-      assert.equal(result, 'testValue')
-    })
-
-    it('should return undefined when config exists but is not ready', () => {
-      const mockApp = {
-        rootDir: '/test',
-        config: {
-          _isReady: false,
-          get: () => 'should not be called'
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-
-      const result = loader.getConfig('someKey')
-
-      assert.equal(result, undefined)
-    })
-
-    it('should always use adapt-authoring-core prefix for config keys', () => {
-      let requestedKey
-      const mockApp = {
-        rootDir: '/test',
-        config: {
-          _isReady: true,
-          get: (key) => { requestedKey = key }
-        }
-      }
-      const loader = new DependencyLoader(mockApp)
-      loader.getConfig('myKey')
-      assert.equal(requestedKey, 'adapt-authoring-core.myKey')
-    })
-  })
-
   describe('#loadConfigs()', () => {
     let testRootDir
 
@@ -339,63 +232,72 @@ describe('DependencyLoader', () => {
   })
 
   describe('#loadModules()', () => {
-    it('should throw DependencyError when module fails without force', async () => {
+    it('should add non-fatal failures to failedModules', async () => {
       const mockApp = { rootDir: '/test' }
       const loader = new DependencyLoader(mockApp)
       loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
 
-      await assert.rejects(
-        loader.loadModules(['nonexistent-module']),
-        { name: 'DependencyError' }
-      )
-    })
-
-    it('should not throw when module fails with force option', async () => {
-      const mockApp = { rootDir: '/test' }
-      const loader = new DependencyLoader(mockApp)
-      loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
-
-      await loader.loadModules(['nonexistent-module'], { force: true })
+      await loader.loadModules(['nonexistent-module'])
 
       assert.ok(loader.failedModules.includes('nonexistent-module'))
     })
 
-    it('should log peer dependency warnings on failure with force', async () => {
+    it('should throw when module throws a fatal error', async () => {
       const mockApp = { rootDir: '/test' }
       const loader = new DependencyLoader(mockApp)
-      loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
-      loader.peerDependencies = { 'nonexistent-module': ['dependent-mod'] }
+      loader.configs = { 'fatal-module': { module: true, name: 'fatal-module' } }
 
-      await loader.loadModules(['nonexistent-module'], { force: true })
+      // monkey-patch loadModule to throw a fatal error
+      const originalLoadModule = loader.loadModule.bind(loader)
+      loader.loadModule = async (name) => {
+        if (name === 'fatal-module') {
+          const error = new Error('Fatal')
+          error.isFatal = true
+          throw error
+        }
+        return originalLoadModule(name)
+      }
 
-      assert.ok(loader.failedModules.includes('nonexistent-module'))
+      await assert.rejects(
+        loader.loadModules(['fatal-module']),
+        (err) => {
+          assert.equal(err.isFatal, true)
+          return true
+        }
+      )
     })
 
-    it('should include module name in DependencyError message', async () => {
+    it('should throw when error.cause is fatal', async () => {
       const mockApp = { rootDir: '/test' }
       const loader = new DependencyLoader(mockApp)
-      loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
+      loader.configs = { 'fatal-module': { module: true, name: 'fatal-module' } }
+
+      loader.loadModule = async () => {
+        const cause = new Error('Root cause')
+        cause.isFatal = true
+        const error = new Error('Wrapper')
+        error.cause = cause
+        throw error
+      }
 
       await assert.rejects(
-        loader.loadModules(['nonexistent-module']),
+        loader.loadModules(['fatal-module']),
         (err) => {
-          assert.ok(err.message.includes('nonexistent-module'))
+          assert.equal(err.cause.isFatal, true)
           return true
         }
       )
     })
 
-    it('should set cause on DependencyError', async () => {
+    it('should log peer dependency warnings on non-fatal failure', async () => {
       const mockApp = { rootDir: '/test' }
       const loader = new DependencyLoader(mockApp)
       loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
+      loader.peerDependencies = { 'nonexistent-module': ['dependent-mod'] }
 
-      try {
-        await loader.loadModules(['nonexistent-module'])
-        assert.fail('should have thrown')
-      } catch (err) {
-        assert.ok(err.cause)
-      }
+      await loader.loadModules(['nonexistent-module'])
+
+      assert.ok(loader.failedModules.includes('nonexistent-module'))
     })
 
     it('should handle empty module list', async () => {
@@ -410,13 +312,18 @@ describe('DependencyLoader', () => {
 
   describe('#loadModule()', () => {
     it('should throw when module already exists', async () => {
-      const mockApp = { rootDir: '/test' }
+      const mockApp = {
+        rootDir: '/test',
+        errors: {
+          DEP_ALREADY_LOADED: new AdaptError('DEP_ALREADY_LOADED')
+        }
+      }
       const loader = new DependencyLoader(mockApp)
       loader.instances = { 'existing-module': {} }
 
       await assert.rejects(
         loader.loadModule('existing-module'),
-        { message: 'Module already exists' }
+        { code: 'DEP_ALREADY_LOADED' }
       )
     })
 
@@ -443,19 +350,29 @@ describe('DependencyLoader', () => {
 
   describe('#waitForModule()', () => {
     it('should throw for missing module', async () => {
-      const mockApp = { rootDir: '/test' }
+      const mockApp = {
+        rootDir: '/test',
+        errors: {
+          DEP_MISSING: new AdaptError('DEP_MISSING')
+        }
+      }
       const loader = new DependencyLoader(mockApp)
       loader._configsLoaded = true
       loader.configs = {}
 
       await assert.rejects(
         loader.waitForModule('adapt-authoring-missing'),
-        { message: "Missing required module 'adapt-authoring-missing'" }
+        { code: 'DEP_MISSING' }
       )
     })
 
     it('should throw for failed module', async () => {
-      const mockApp = { rootDir: '/test' }
+      const mockApp = {
+        rootDir: '/test',
+        errors: {
+          DEP_FAILED: new AdaptError('DEP_FAILED')
+        }
+      }
       const loader = new DependencyLoader(mockApp)
       loader._configsLoaded = true
       loader.configs = { 'adapt-authoring-failed': { name: 'adapt-authoring-failed' } }
@@ -463,7 +380,7 @@ describe('DependencyLoader', () => {
 
       await assert.rejects(
         loader.waitForModule('adapt-authoring-failed'),
-        { message: "Dependency 'adapt-authoring-failed' failed to load" }
+        { code: 'DEP_FAILED' }
       )
     })
 
@@ -601,7 +518,6 @@ describe('DependencyLoader', () => {
       const mockApp = {
         rootDir: '/test',
         logger: {
-          _isReady: true,
           log: (level, name, ...args) => {
             if (typeof args[0] === 'object' && !Array.isArray(args[0]) && typeof args[0] !== 'string') {
               loggedTimes = args[0]
@@ -628,7 +544,6 @@ describe('DependencyLoader', () => {
       const mockApp = {
         rootDir: '/test',
         logger: {
-          _isReady: true,
           log: (level, name, ...args) => {
             if (typeof args[0] === 'string' && args[0] === 'LOAD') {
               loggedMessage = args[1]

package/tests/Errors.spec.js

@@ -0,0 +1,91 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import Errors from '../lib/Errors.js'
+import AdaptError from '../lib/AdaptError.js'
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+describe('Errors', () => {
+  let testDir
+
+  before(async () => {
+    testDir = path.join(__dirname, 'data', 'errors-test')
+    const errorsDir = path.join(testDir, 'errors')
+    await fs.ensureDir(errorsDir)
+    await fs.writeJson(path.join(errorsDir, 'test.json'), {
+      TEST_ERROR: {
+        description: 'A test error',
+        statusCode: 400,
+        data: { id: 'The item ID' }
+      },
+      FATAL_ERROR: {
+        description: 'A fatal error',
+        statusCode: 500,
+        isFatal: true
+      }
+    })
+  })
+
+  after(async () => {
+    await fs.remove(testDir)
+  })
+
+  describe('constructor', () => {
+    it('should load error definitions from dependencies', () => {
+      const deps = { test: { name: 'test', rootDir: testDir } }
+      const errors = new Errors({ dependencies: deps })
+      assert.ok(errors.TEST_ERROR)
+      assert.ok(errors.FATAL_ERROR)
+    })
+
+    it('should return AdaptError instances', () => {
+      const deps = { test: { name: 'test', rootDir: testDir } }
+      const errors = new Errors({ dependencies: deps })
+      assert.ok(errors.TEST_ERROR instanceof AdaptError)
+    })
+
+    it('should return fresh instances on each access', () => {
+      const deps = { test: { name: 'test', rootDir: testDir } }
+      const errors = new Errors({ dependencies: deps })
+      assert.notEqual(errors.TEST_ERROR, errors.TEST_ERROR)
+    })
+
+    it('should set statusCode from definition', () => {
+      const deps = { test: { name: 'test', rootDir: testDir } }
+      const errors = new Errors({ dependencies: deps })
+      assert.equal(errors.TEST_ERROR.statusCode, 400)
+    })
+
+    it('should set isFatal from definition', () => {
+      const deps = { test: { name: 'test', rootDir: testDir } }
+      const errors = new Errors({ dependencies: deps })
+      assert.equal(errors.FATAL_ERROR.isFatal, true)
+      assert.equal(errors.TEST_ERROR.isFatal, false)
+    })
+
+    it('should warn on duplicate error codes', () => {
+      const dupDir = path.join(__dirname, 'data', 'errors-dup')
+      const errorsDir = path.join(dupDir, 'errors')
+      fs.ensureDirSync(errorsDir)
+      fs.writeJsonSync(path.join(errorsDir, 'dup.json'), {
+        TEST_ERROR: { description: 'duplicate', statusCode: 500 }
+      })
+      const deps = {
+        test: { name: 'test', rootDir: testDir },
+        dup: { name: 'dup', rootDir: dupDir }
+      }
+      let warned = false
+      new Errors({ dependencies: deps, log: () => { warned = true } }) // eslint-disable-line no-new
+      assert.ok(warned)
+      fs.removeSync(dupDir)
+    })
+
+    it('should handle empty dependencies', () => {
+      const errors = new Errors({ dependencies: {} })
+      assert.deepEqual(Object.keys(errors), [])
+    })
+  })
+})

package/tests/Lang.spec.js

@@ -0,0 +1,116 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import Lang from '../lib/Lang.js'
+import fs from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+function createLang (phrases, defaultLang = 'en') {
+  const lang = new Lang({ dependencies: {}, defaultLang, rootDir: __dirname })
+  lang.phrases = phrases
+  return lang
+}
+
+describe('Lang', () => {
+  let testDir
+
+  before(async () => {
+    testDir = path.join(__dirname, 'data', 'lang-test')
+    const langDir = path.join(testDir, 'lang')
+    await fs.ensureDir(langDir)
+    await fs.writeJson(path.join(langDir, 'en.json'), {
+      'app.name': 'Test App',
+      'app.greeting': 'Hello ${name}', // eslint-disable-line no-template-curly-in-string
+      'error.TEST_ERROR': 'A test error occurred'
+    })
+    await fs.writeJson(path.join(langDir, 'fr.json'), {
+      'app.name': 'Application Test'
+    })
+  })
+
+  after(async () => {
+    await fs.remove(testDir)
+  })
+
+  describe('#loadPhrases()', () => {
+    it('should load phrases from dependencies', async () => {
+      const lang = new Lang()
+      await lang.loadPhrases({ test: { rootDir: testDir } }, testDir)
+      assert.ok(lang.phrases.en)
+      assert.equal(lang.phrases.en['app.name'], 'Test App')
+    })
+
+    it('should load multiple languages', async () => {
+      const lang = new Lang()
+      await lang.loadPhrases({ test: { rootDir: testDir } }, testDir)
+      assert.ok(lang.phrases.fr)
+      assert.equal(lang.phrases.fr['app.name'], 'Application Test')
+    })
+  })
+
+  describe('#supportedLanguages', () => {
+    it('should return loaded language keys', async () => {
+      const lang = new Lang()
+      await lang.loadPhrases({ test: { rootDir: testDir } }, testDir)
+      const languages = lang.supportedLanguages
+      assert.ok(languages.includes('en'))
+      assert.ok(languages.includes('fr'))
+    })
+  })
+
+  describe('#translate()', () => {
+    it('should return translated string', () => {
+      const lang = createLang({ en: { hello: 'Hello' } })
+      assert.equal(lang.translate('en', 'hello'), 'Hello')
+    })
+
+    it('should substitute data placeholders', () => {
+      // eslint-disable-next-line no-template-curly-in-string
+      const lang = createLang({ en: { greeting: 'Hello ${name}' } })
+      assert.equal(lang.translate('en', 'greeting', { name: 'World' }), 'Hello World')
+    })
+
+    it('should fall back to default lang when lang is not a string', () => {
+      const lang = createLang({ en: { hello: 'Hello' } })
+      assert.equal(lang.translate(undefined, 'hello'), 'Hello')
+    })
+
+    it('should return key and warn when key is missing', () => {
+      let warned = false
+      const lang = createLang({ en: {} })
+      lang.log = () => { warned = true }
+      assert.equal(lang.translate('en', 'missing.key'), 'missing.key')
+      assert.ok(warned)
+    })
+
+    it('should return non-error, non-string values unchanged', () => {
+      const lang = createLang({})
+      assert.equal(lang.translate('en', 42), 42)
+    })
+
+    it('should translate an error using its code', () => {
+      const lang = createLang({ en: { 'error.TEST': 'Translated error' } })
+      const error = new Error('TEST')
+      error.code = 'TEST'
+      assert.equal(lang.translate('en', error), 'Translated error')
+    })
+
+    it('should fall back to error message when error has no code', () => {
+      const lang = createLang({ en: {} })
+      lang.log = () => {}
+      assert.equal(lang.translate('en', new Error('boom')), 'boom')
+    })
+
+    it('should substitute a code-less error in data using its message', () => {
+      // eslint-disable-next-line no-template-curly-in-string
+      const lang = createLang({ en: { 'error.OUTER': 'Failed: ${cause}' } })
+      lang.log = () => {}
+      const outer = new Error('OUTER')
+      outer.code = 'OUTER'
+      outer.data = { cause: new Error('disk full') }
+      assert.equal(lang.translate('en', outer), 'Failed: disk full')
+    })
+  })
+})