adapt-authoring-core 1.8.0 → 1.9.1

package/.github/workflows/tests.yml

@@ -0,0 +1,15 @@
+name: Tests
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/lib/AbstractModule.js

@@ -74,6 +74,7 @@ class AbstractModule {
     if (!error) {
       this._isReady = true
     }
+    /** @ignore */ this._initError = error
     this.initTime = Math.round((Date.now() - this._startTime))
     this.log('verbose', AbstractModule.MODULE_READY, this.initTime)
     await this.readyHook.invoke(error)
@@ -86,7 +87,10 @@ class AbstractModule {
   async onReady () {
     return new Promise((resolve, reject) => {
       if (this._isReady) {
-        return this._initError ? reject(this._initError) : resolve(this)
+        return resolve(this)
+      }
+      if (this._initError) {
+        return reject(this._initError)
       }
       this.readyHook.tap(error => {
         /** @ignore */this._initError = error

package/lib/Hook.js

@@ -58,7 +58,7 @@ class Hook {
    * @returns Promise
    */
   onInvoke () {
-    return new Promise((resolve, reject) => this._hookObservers.push([resolve, reject]))
+    return new Promise((resolve, reject) => this._promiseObservers.push([resolve, reject]))
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-core",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "A bundle of reusable 'core' functionality",
   "homepage": "https://github.com/adapt-security/adapt-authoring-core",
   "license": "GPL-3.0",

package/tests/AbstractModule.spec.js

@@ -66,6 +66,69 @@ describe('AbstractModule', () => {
       await module.readyHook.invoke()
       assert.equal(hookCalled, true)
     })
+
+    it('should use constructor name when pkg is undefined', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, undefined)
+      await module.onReady()
+      assert.equal(module.name, 'AbstractModule')
+    })
+
+    it('should use subclass constructor name when pkg.name is empty', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+
+      class MyCustomModule extends AbstractModule {
+        async init () {}
+      }
+
+      const module = new MyCustomModule(mockApp, { name: '' })
+      await module.onReady()
+      assert.equal(module.name, 'MyCustomModule')
+    })
+
+    it('should set _startTime during construction', async () => {
+      const before = Date.now()
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test' })
+      const after = Date.now()
+      await module.onReady()
+      assert.ok(module._startTime >= before)
+      assert.ok(module._startTime <= after)
+    })
+
+    it('should initialise initTime as undefined', () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test' })
+      assert.equal(module.initTime, undefined)
+    })
   })
 
   describe('#init()', () => {
@@ -111,6 +174,43 @@ describe('AbstractModule', () => {
       const module = new TestModule(mockApp, { name: 'test' })
       await assert.rejects(module.onReady(), { message: 'init error' })
     })
+
+    it('should handle async init that resolves', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      let completed = false
+
+      class TestModule extends AbstractModule {
+        async init () {
+          await new Promise(resolve => setTimeout(resolve, 5))
+          completed = true
+        }
+      }
+
+      const module = new TestModule(mockApp, { name: 'test' })
+      await module.onReady()
+      assert.equal(completed, true)
+    })
+
+    it('should default init to a no-op that resolves', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test' })
+      await module.onReady()
+      assert.equal(module._isReady, true)
+    })
   })
 
   describe('#setReady()', () => {
@@ -192,6 +292,28 @@ describe('AbstractModule', () => {
 
       assert.equal(module.initTime, firstInitTime)
     })
+
+    it('should calculate initTime even on error', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+
+      class TestModule extends AbstractModule {
+        async init () {
+          throw new Error('fail')
+        }
+      }
+
+      const module = new TestModule(mockApp, { name: 'test' })
+      try { await module.onReady() } catch (e) { /* expected */ }
+      assert.equal(typeof module.initTime, 'number')
+      assert.ok(module.initTime >= 0)
+    })
   })
 
   describe('#onReady()', () => {
@@ -264,6 +386,24 @@ describe('AbstractModule', () => {
 
       assert.equal(resolvedModule, module)
     })
+
+    // TODO: Bug - onReady() hangs forever after a failed init, because _isReady
+    // remains false and readyHook has already been invoked, so the tap never fires.
+    // Calling onReady() a second time after a failure will never resolve or reject.
+    it('should support multiple concurrent onReady calls', async () => {
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test' })
+      const [r1, r2] = await Promise.all([module.onReady(), module.onReady()])
+      assert.equal(r1, module)
+      assert.equal(r2, module)
+    })
   })
 
   describe('#getConfig()', () => {
@@ -330,6 +470,28 @@ describe('AbstractModule', () => {
 
       assert.equal(result, undefined)
     })
+
+    it('should construct key from module name and config key', async () => {
+      let requestedKey
+      const mockApp = {
+        config: {
+          get: (key) => { requestedKey = key; return 'value' }
+        },
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: () => {},
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'my-module' })
+
+      await module.onReady()
+
+      module.getConfig('myKey')
+
+      assert.equal(requestedKey, 'my-module.myKey')
+    })
   })
 
   describe('#log()', () => {
@@ -452,6 +614,59 @@ describe('AbstractModule', () => {
 
       assert.deepEqual(loggedArgs, ['arg1', 'arg2', 'arg3'])
     })
+
+    it('should queue log and deliver when logger module loads', async () => {
+      let loggedLevel
+      let tapCallback
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: (fn) => { tapCallback = fn },
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test-mod' })
+      await module.onReady()
+
+      module.log('warn', 'deferred message')
+      assert.ok(tapCallback)
+
+      mockApp.logger = {
+        name: 'adapt-authoring-logger',
+        log: (level) => {
+          loggedLevel = level
+        }
+      }
+
+      tapCallback(null, { name: 'adapt-authoring-logger' })
+      assert.equal(loggedLevel, 'warn')
+    })
+
+    it('should not log when loaded module is not the logger', async () => {
+      const logCalled = false
+      let tapCallback
+      const mockApp = {
+        dependencyloader: {
+          moduleLoadedHook: {
+            tap: (fn) => { tapCallback = fn },
+            untap: () => {}
+          }
+        }
+      }
+      const module = new AbstractModule(mockApp, { name: 'test-mod' })
+      await module.onReady()
+
+      // No logger set yet, so log queues the callback
+      module.log('info', 'some message')
+      assert.ok(tapCallback)
+
+      // Now simulate a non-logger module loading - _log checks !this.app.logger
+      // which is true (no logger), so it returns false
+      const result = tapCallback(null, { name: 'adapt-authoring-other' })
+      assert.equal(result, false)
+      assert.equal(logCalled, false)
+    })
   })
 
   describe('constructor with null pkg', () => {

package/tests/App.spec.js

@@ -40,13 +40,30 @@ describe('App', () => {
       assert.ok(app instanceof App)
     })
 
-    it('should return the same instance on subsequent calls', () => {
+    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
@@ -70,6 +87,25 @@ describe('App', () => {
       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()', () => {
@@ -100,5 +136,25 @@ describe('App', () => {
       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)
+    })
   })
 })

package/tests/DependencyLoader.spec.js

@@ -38,6 +38,18 @@ describe('DependencyLoader', () => {
       assert.equal(typeof loader.configsLoadedHook.invoke, 'function')
       assert.equal(typeof loader.moduleLoadedHook.invoke, 'function')
     })
+
+    it('should tap logProgress into moduleLoadedHook', () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      assert.ok(loader.moduleLoadedHook.hasObservers)
+    })
+
+    it('should derive name from constructor name in lowercase', () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      assert.equal(loader.name, 'dependencyloader')
+    })
   })
 
   describe('#log()', () => {
@@ -80,6 +92,27 @@ describe('DependencyLoader', () => {
         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
+            loggedArgs = args
+          }
+        }
+      }
+      const loader = new DependencyLoader(mockApp)
+      loader.log('warn', 'message1', 'message2')
+
+      assert.equal(loggedLevel, 'warn')
+      assert.equal(loggedName, 'dependencyloader')
+      assert.deepEqual(loggedArgs, ['message1', 'message2'])
+    })
   })
 
   describe('#logError()', () => {
@@ -98,6 +131,20 @@ describe('DependencyLoader', () => {
 
       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()', () => {
@@ -128,6 +175,35 @@ describe('DependencyLoader', () => {
 
       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('#loadModuleConfig()', () => {
@@ -166,6 +242,37 @@ describe('DependencyLoader', () => {
       assert.equal(config.essentialType, 'api')
       assert.equal(config.rootDir, testModuleDir)
     })
+
+    it('should override package.json values with adapt-authoring.json values', async () => {
+      const overrideDir = path.join(__dirname, 'data', 'override-module')
+      await fs.ensureDir(overrideDir)
+      await fs.writeJson(path.join(overrideDir, 'package.json'), {
+        name: 'pkg-name',
+        description: 'from package'
+      })
+      await fs.writeJson(path.join(overrideDir, 'adapt-authoring.json'), {
+        name: 'adapt-name',
+        description: 'from adapt'
+      })
+
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      const config = await loader.loadModuleConfig(overrideDir)
+
+      assert.equal(config.name, 'adapt-name')
+      assert.equal(config.description, 'from adapt')
+
+      await fs.remove(overrideDir)
+    })
+
+    it('should set rootDir to the module directory', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+
+      const config = await loader.loadModuleConfig(testModuleDir)
+
+      assert.equal(config.rootDir, testModuleDir)
+    })
   })
 
   describe('#loadModules()', () => {
@@ -200,6 +307,42 @@ describe('DependencyLoader', () => {
 
       assert.ok(loader.failedModules.includes('nonexistent-module'))
     })
+
+    it('should include module name in DependencyError message', 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']),
+        (err) => {
+          assert.ok(err.message.includes('nonexistent-module'))
+          return true
+        }
+      )
+    })
+
+    it('should set cause on DependencyError', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      loader.configs = { 'nonexistent-module': { module: true, name: 'nonexistent-module' } }
+
+      try {
+        await loader.loadModules(['nonexistent-module'])
+        assert.fail('should have thrown')
+      } catch (err) {
+        assert.ok(err.cause)
+      }
+    })
+
+    it('should handle empty module list', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+
+      await loader.loadModules([])
+
+      assert.deepEqual(loader.failedModules, [])
+    })
   })
 
   describe('#loadModule()', () => {
@@ -223,6 +366,16 @@ describe('DependencyLoader', () => {
 
       assert.equal(result, undefined)
     })
+
+    it('should not add to instances when config.module is false', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      loader.configs = { 'non-module': { module: false } }
+
+      await loader.loadModule('non-module')
+
+      assert.equal(loader.instances['non-module'], undefined)
+    })
   })
 
   describe('#waitForModule()', () => {
@@ -284,6 +437,39 @@ describe('DependencyLoader', () => {
 
       assert.equal(result, mockInstance)
     })
+
+    it('should not double-prefix names that already have the prefix', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      loader._configsLoaded = true
+      const mockInstance = {
+        name: 'adapt-authoring-server',
+        _isReady: true,
+        onReady: async () => mockInstance
+      }
+      loader.configs = { 'adapt-authoring-server': { name: 'adapt-authoring-server' } }
+      loader.instances = { 'adapt-authoring-server': mockInstance }
+
+      const result = await loader.waitForModule('adapt-authoring-server')
+
+      assert.equal(result, mockInstance)
+    })
+
+    it('should resolve via moduleLoadedHook when module not yet loaded', async () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      loader._configsLoaded = true
+      loader.configs = { 'adapt-authoring-pending': { name: 'adapt-authoring-pending' } }
+
+      const mockInstance = { name: 'adapt-authoring-pending' }
+
+      const waitPromise = loader.waitForModule('adapt-authoring-pending')
+
+      await loader.moduleLoadedHook.invoke(null, mockInstance)
+
+      const result = await waitPromise
+      assert.equal(result, mockInstance)
+    })
   })
 
   describe('#logProgress()', () => {
@@ -332,5 +518,75 @@ describe('DependencyLoader', () => {
         loader.logProgress(null, { name: 'test-module', initTime: 50 })
       })
     })
+
+    it('should count module being loaded as loaded even before _isReady', () => {
+      const mockApp = { rootDir: '/test' }
+      const loader = new DependencyLoader(mockApp)
+      loader.configs = {
+        'mod-a': { name: 'mod-a', module: true },
+        'mod-b': { name: 'mod-b', module: true }
+      }
+      loader.instances = {}
+
+      assert.doesNotThrow(() => {
+        loader.logProgress(null, { name: 'mod-a', initTime: 10 })
+      })
+    })
+
+    it('should log init times at 100% progress', () => {
+      let loggedTimes
+      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]
+            }
+          }
+        }
+      }
+      const loader = new DependencyLoader(mockApp)
+      loader.configs = {
+        'mod-a': { name: 'mod-a', module: true }
+      }
+      loader.instances = {
+        'mod-a': { name: 'mod-a', _isReady: true, initTime: 42 }
+      }
+
+      loader.logProgress(null, { name: 'mod-a', initTime: 42 })
+
+      assert.ok(loggedTimes)
+      assert.equal(loggedTimes['mod-a'], 42)
+    })
+
+    it('should include failed module names in log output', () => {
+      let loggedMessage
+      const mockApp = {
+        rootDir: '/test',
+        logger: {
+          _isReady: true,
+          log: (level, name, ...args) => {
+            if (typeof args[0] === 'string' && args[0] === 'LOAD') {
+              loggedMessage = args[1]
+            }
+          }
+        }
+      }
+      const loader = new DependencyLoader(mockApp)
+      loader.configs = {
+        'adapt-authoring-ok': { name: 'adapt-authoring-ok', module: true },
+        'adapt-authoring-bad': { name: 'adapt-authoring-bad', module: true }
+      }
+      loader.instances = {
+        'adapt-authoring-ok': { name: 'adapt-authoring-ok', _isReady: true, initTime: 10 }
+      }
+      loader.failedModules = ['adapt-authoring-bad']
+
+      loader.logProgress(null, { name: 'adapt-authoring-ok', initTime: 10 })
+
+      assert.ok(loggedMessage)
+      assert.ok(loggedMessage.includes('failed'))
+    })
   })
 })

package/tests/Hook.spec.js

@@ -13,6 +13,12 @@ describe('Hook', () => {
     })
   })
 
+  describe('.Types', () => {
+    it('should have exactly two type keys', () => {
+      assert.equal(Object.keys(Hook.Types).length, 2)
+    })
+  })
+
   describe('constructor', () => {
     it('should create a hook with default options', () => {
       const hook = new Hook()
@@ -20,6 +26,34 @@ describe('Hook', () => {
       assert.equal(hook.hasObservers, false)
     })
 
+    it('should default to parallel type', () => {
+      const hook = new Hook()
+      assert.equal(hook._options.type, Hook.Types.Parallel)
+    })
+
+    it('should default mutable to false', () => {
+      const hook = new Hook()
+      assert.equal(hook._options.mutable, false)
+    })
+
+    it('should allow explicit type override even when mutable is true', () => {
+      const hook = new Hook({ type: Hook.Types.Parallel, mutable: true })
+      // When type is explicitly provided, it overrides the mutable-forced series default
+      assert.equal(hook._options.type, Hook.Types.Parallel)
+    })
+
+    it('should handle undefined options', () => {
+      const hook = new Hook(undefined)
+      assert.equal(hook._options.type, Hook.Types.Parallel)
+      assert.equal(hook._options.mutable, false)
+    })
+
+    it('should initialise with empty observer arrays', () => {
+      const hook = new Hook()
+      assert.deepEqual(hook._hookObservers, [])
+      assert.deepEqual(hook._promiseObservers, [])
+    })
+
     it('should create a hook that supports parallel execution', async () => {
       const hook = new Hook()
       const results = []
@@ -100,8 +134,19 @@ describe('Hook', () => {
       hook.tap('not a function')
       hook.tap(null)
       hook.tap(42)
+      hook.tap(undefined)
+      hook.tap({})
+      hook.tap([])
       assert.equal(hook.hasObservers, false)
     })
+
+    it('should work without scope argument', async () => {
+      const hook = new Hook()
+      let called = false
+      hook.tap(() => { called = true })
+      await hook.invoke()
+      assert.equal(called, true)
+    })
   })
 
   describe('#untap()', () => {
@@ -122,6 +167,23 @@ describe('Hook', () => {
       // observer still present because tap binds the function
       assert.equal(hook.hasObservers, true)
     })
+
+    it('should remove a directly-pushed observer by reference', () => {
+      const hook = new Hook()
+      const fn = () => {}
+      hook._hookObservers.push(fn)
+      assert.equal(hook.hasObservers, true)
+      hook.untap(fn)
+      assert.equal(hook.hasObservers, false)
+    })
+
+    it('should only remove the first matching reference', () => {
+      const hook = new Hook()
+      const fn = () => {}
+      hook._hookObservers.push(fn, fn)
+      hook.untap(fn)
+      assert.equal(hook._hookObservers.length, 1)
+    })
   })
 
   describe('#invoke()', () => {
@@ -187,6 +249,14 @@ describe('Hook', () => {
         const result = await hook.invoke()
         assert.deepEqual(result, [])
       })
+
+      it('should handle mixed sync and async observers', async () => {
+        const hook = new Hook()
+        hook.tap(() => 'sync')
+        hook.tap(async () => 'async')
+        const result = await hook.invoke()
+        assert.deepEqual(result, ['sync', 'async'])
+      })
     })
 
     describe('series hooks', () => {
@@ -228,6 +298,28 @@ describe('Hook', () => {
         hook.tap(() => { throw new Error('series error') })
         await assert.rejects(hook.invoke(), { message: 'series error' })
       })
+
+      it('should stop on first error and not call subsequent observers', async () => {
+        const hook = new Hook({ type: Hook.Types.Series })
+        const calls = []
+        hook.tap(() => { calls.push(1); throw new Error('stop') })
+        hook.tap(() => calls.push(2))
+        await assert.rejects(hook.invoke())
+        assert.deepEqual(calls, [1])
+      })
+
+      it('should return undefined with no observers', async () => {
+        const hook = new Hook({ type: Hook.Types.Series })
+        const result = await hook.invoke()
+        assert.equal(result, undefined)
+      })
+
+      it('should return single observer result', async () => {
+        const hook = new Hook({ type: Hook.Types.Series })
+        hook.tap(() => 'only')
+        const result = await hook.invoke()
+        assert.equal(result, 'only')
+      })
     })
 
     describe('mutable hooks', () => {
@@ -239,6 +331,16 @@ describe('Hook', () => {
         await hook.invoke(obj)
         assert.equal(obj.value, 3)
       })
+
+      it('should allow multiple mutations in sequence', async () => {
+        const hook = new Hook({ mutable: true })
+        const arr = []
+        hook.tap((a) => { a.push(1) })
+        hook.tap((a) => { a.push(2) })
+        hook.tap((a) => { a.push(3) })
+        await hook.invoke(arr)
+        assert.deepEqual(arr, [1, 2, 3])
+      })
     })
   })
 
@@ -249,11 +351,19 @@ describe('Hook', () => {
       assert.ok(result instanceof Promise)
     })
 
-    it('should add an entry to hook observers', () => {
+    it('should add an entry to promise observers', () => {
       const hook = new Hook()
-      assert.equal(hook.hasObservers, false)
+      assert.equal(hook._promiseObservers.length, 0)
       hook.onInvoke()
-      assert.equal(hook.hasObservers, true)
+      assert.equal(hook._promiseObservers.length, 1)
+    })
+
+    it('should add a resolve/reject pair as promise observer', () => {
+      const hook = new Hook()
+      hook.onInvoke()
+      const observer = hook._promiseObservers[0]
+      assert.ok(Array.isArray(observer))
+      assert.equal(observer.length, 2)
     })
   })
 })

package/tests/Utils.spec.js

@@ -21,6 +21,16 @@ describe('Utils', () => {
       assert.equal(typeof args, 'object')
       assert.ok(Array.isArray(args.params))
     })
+
+    it('should include the underscore array from minimist', () => {
+      const args = Utils.getArgs()
+      assert.ok(Array.isArray(args._))
+    })
+
+    it('should derive params by slicing first two entries from _', () => {
+      const args = Utils.getArgs()
+      assert.deepEqual(args.params, args._.slice(2))
+    })
   })
 
   describe('.isObject()', () => {