adapt-authoring-config 1.1.5 → 1.3.0

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@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/lib/ConfigModule.js

@@ -21,11 +21,6 @@ class ConfigModule extends AbstractModule {
      * @type {String}
      */
     this.configFilePath = path.join(this.app.rootDir, 'conf', `${process.env.NODE_ENV}.config.js`)
-    /**
-     * The keys for all attributes which can be modified during runtime
-     * @type {Array<String>}
-     */
-    this.mutableAttributes = []
     /**
      * The keys for all attributes marked as public
      * @type {Array<String>}
@@ -61,7 +56,7 @@ class ConfigModule extends AbstractModule {
     const [auth, server] = await this.app.waitForModule('auth', 'server')
     const router = server.api.createChildRouter('config', [{
       route: '/',
-      handlers: { get: (req, res) => res.json(this.getPublicConfig(req.params.mutable)) },
+      handlers: { get: (_req, res) => res.json(this.getPublicConfig()) },
       meta: {
         get: {
           summary: 'Retrieve public config data',
@@ -86,7 +81,7 @@ class ConfigModule extends AbstractModule {
       try { // try to parse to allow for non-string values
         val = JSON.parse(val)
       } catch {} // ignore errors
-      this.set(this.envVarToConfigKey(key), val)
+      this._config[this.envVarToConfigKey(key)] = val
     })
   }
 
@@ -126,7 +121,7 @@ class ConfigModule extends AbstractModule {
     }
     Object.entries(config).forEach(([name, c]) => {
       Object.entries(c).forEach(([key, val]) => {
-        this.set(`${name}.${key}`, val)
+        this._config[`${name}.${key}`] = val
       })
     })
   }
@@ -178,7 +173,6 @@ class ConfigModule extends AbstractModule {
     }
     // validate user config data
     let data = Object.entries(schema.raw.properties).reduce((m, [k, v]) => {
-      if (v?._adapt?.isMutable) this.mutableAttributes.push(`${pkg.name}.${k}`)
       if (v?._adapt?.isPublic) this.publicAttributes.push(`${pkg.name}.${k}`)
       return { ...m, [k]: this.get(`${pkg.name}.${k}`) }
     }, {})
@@ -189,7 +183,7 @@ class ConfigModule extends AbstractModule {
       throw e
     }
     // apply validated config settings
-    Object.entries(data).forEach(([key, val]) => this.set(`${pkg.name}.${key}`, val, { force: true }))
+    Object.entries(data).forEach(([key, val]) => { this._config[`${pkg.name}.${key}`] = val })
   }
 
   /**
@@ -210,30 +204,13 @@ class ConfigModule extends AbstractModule {
     return this._config[attr]
   }
 
-  /**
-   * Stores a value for the passed attribute
-   * @param {String} attr Attribute key name
-   * @param {*} val Value to set
-   * @param {objeect} options Custom options
-   * @param {objeect} options.force Whether to force an update
-   */
-  set (attr, val, options = {}) {
-    if (this.has(attr) && !this.mutableAttributes.includes(attr) && options.force !== true) {
-      return
-    }
-    this._config[attr] = val
-  }
-
   /**
    * Retrieves all config options marked as 'public'
-   * @param {Boolean} isMutable Whether options should also be mutable
    * @return {Object}
    */
-  getPublicConfig (isMutable) {
+  getPublicConfig () {
     return this.publicAttributes.reduce((m, a) => {
-      if (!isMutable || (isMutable && this.mutableAttributes.includes(a))) {
-        m[a] = this.get(a)
-      }
+      m[a] = this.get(a)
       return m
     }, {})
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-config",
-  "version": "1.1.5",
+  "version": "1.3.0",
   "description": "A configuration module for the Adapt authoring tool.",
   "homepage": "https://github.com/adapt-security/adapt-authoring-config",
   "license": "GPL-3.0",
@@ -9,6 +9,9 @@
   "bin": {
     "at-confgen": "./bin/confgen.js"
   },
+  "scripts": {
+    "test": "node --test tests/*.spec.js"
+  },
   "repository": "github:adapt-security/adapt-authoring-config",
   "dependencies": {
     "adapt-authoring-core": "^1.7.0",
@@ -16,7 +19,7 @@
     "glob": "^13.0.0"
   },
   "peerDependencies": {
-    "adapt-authoring-auth": "^1.0.5",
+    "adapt-authoring-auth": "^1.0.7",
     "adapt-authoring-errors": "^1.1.2",
     "adapt-authoring-jsonschema": "^1.2.0",
     "adapt-authoring-server": "^1.2.1"

package/tests/configModule.spec.js

@@ -1,63 +1,136 @@
-/* global before describe, it */
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert/strict'
+import ConfigModule from '../lib/ConfigModule.js'
 
-const Config = require('../lib/configUtils')
-const path = require('path')
-// const should = require('should')
+describe('ConfigModule', () => {
+  let instance
 
-describe('Config module', function () {
-  before(function () {
-    this.config = new Config(global.ADAPT.app, {})
-    this.configJson = require(path.join(process.cwd(), 'conf', 'testing.config.js'))
-  })
-  describe('#initialise()', function () {
-    it('should error on missing required attribute', runConfigInitialise('required'))
-    it('should error on incorrect attribute type', runConfigInitialise('incorrecttype'))
-    it('should error on validator fail', runConfigInitialise('invalid'))
+  before(async () => {
+    const noopHook = { tap: () => {}, untap: () => {}, invoke: async () => {} }
+    const noopRouter = { path: '/', createChildRouter: () => noopRouter }
+    const mockApp = {
+      config: null,
+      rootDir: '/test',
+      name: 'test-app',
+      dependencies: {},
+      dependencyloader: { moduleLoadedHook: noopHook },
+      waitForModule: async (...names) => {
+        const mocks = {
+          errors: { LOAD_ERROR: new Error('load') },
+          auth: { unsecureRoute: () => {} },
+          server: { api: { createChildRouter: () => noopRouter } },
+          jsonschema: { createSchema: async () => ({ build: async () => ({}) }) }
+        }
+        const results = names.map(n => mocks[n] || {})
+        return results.length === 1 ? results[0] : results
+      },
+      errors: { LOAD_ERROR: new Error('load') }
+    }
+
+    instance = new ConfigModule(mockApp, {})
+
+    // Wait for the async init to settle (it will error in test mode, which is fine)
+    try { await instance.onReady() } catch (e) { /* expected */ }
+
+    // Ensure internal state is initialized for testing
+    if (!instance._config) instance._config = {}
+    if (!instance.publicAttributes) instance.publicAttributes = []
   })
-  describe('#has()', function () {
-    it('should be able to verify a value exists', function () {
-      const exists = this.config.has('adapt-authoring-testing.test')
-      exists.should.be.true()
+
+  describe('#envVarToConfigKey()', () => {
+    it('should convert ADAPT_AUTHORING prefixed env vars to config keys', () => {
+      const result = instance.envVarToConfigKey('ADAPT_AUTHORING_SERVER__PORT')
+      assert.equal(result, 'adapt-authoring-server.PORT')
+    })
+
+    it('should convert underscores to hyphens in module prefix', () => {
+      const result = instance.envVarToConfigKey('ADAPT_AUTHORING_MY_MODULE__KEY')
+      assert.equal(result, 'adapt-authoring-my-module.KEY')
     })
-    it('should be able to verify a value doesn\'t exist', function () {
-      const exists = this.config.has('adapt-authoring-testing.nonono')
-      exists.should.not.be.true()
+
+    it('should prefix non-ADAPT_AUTHORING env vars with "env."', () => {
+      const result = instance.envVarToConfigKey('NODE_ENV')
+      assert.equal(result, 'env.NODE_ENV')
+    })
+
+    it('should handle env vars without double underscore', () => {
+      // When no __ separator exists, key will be undefined
+      // This documents the current behavior of the function
+      const result = instance.envVarToConfigKey('ADAPT_AUTHORING_TEST')
+      assert.equal(result, 'adapt-authoring-test.undefined')
     })
   })
-  describe('#get()', function () {
-    it('should be able to retrieve a value', function () {
-      const actualValue = this.config.get('adapt-authoring-testing.test')
-      const expectedValue = this.configJson['adapt-authoring-testing'].test
-      actualValue.should.equal(expectedValue)
+
+  describe('#has()', () => {
+    it('should return true for existing config values', () => {
+      instance._config['test.key'] = 'value'
+      const exists = instance.has('test.key')
+      assert.equal(exists, true)
+    })
+
+    it('should return false for non-existent config values', () => {
+      const exists = instance.has('nonexistent.key')
+      assert.equal(exists, false)
     })
   })
-  describe('#set()', function () {
-    it('should be able to set a value', function () {
-      const newValue = 'newtestvalue'
-      this.config.set('adapt-authoring-testing.test', newValue)
-      const actualValue = this.config.get('adapt-authoring-testing.test')
-      actualValue.should.equal(newValue)
+
+  describe('#get()', () => {
+    it('should retrieve a stored value', () => {
+      instance._config['test.value'] = 'expected'
+      const actual = instance.get('test.value')
+      assert.equal(actual, 'expected')
+    })
+
+    it('should return undefined for non-existent keys', () => {
+      const actual = instance.get('does.not.exist')
+      assert.equal(actual, undefined)
+    })
+
+    it('should retrieve different data types', () => {
+      instance._config['test.string'] = 'text'
+      instance._config['test.number'] = 42
+      instance._config['test.boolean'] = true
+      instance._config['test.object'] = { key: 'value' }
+
+      assert.equal(instance.get('test.string'), 'text')
+      assert.equal(instance.get('test.number'), 42)
+      assert.equal(instance.get('test.boolean'), true)
+      assert.deepEqual(instance.get('test.object'), { key: 'value' })
     })
   })
-  describe('#getPublicConfig()', function () {
-    it('should be able to retrieve values marked as public', function () {
-      this.config.app.dependencies = [{ name: 'adapt-authoring-testing', dir: path.join(__dirname, 'data') }]
-      this.config.initialise()
-      const config = this.config.getPublicConfig()
-      const value = config['adapt-authoring-testing.one']
-      config.should.be.an.Object()
-      value.should.equal('default')
+
+  describe('#getPublicConfig()', () => {
+    it('should return only public attributes', () => {
+      instance._config = {
+        'module.public1': 'value1',
+        'module.public2': 'value2',
+        'module.private': 'secret'
+      }
+      instance.publicAttributes = ['module.public1', 'module.public2']
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {
+        'module.public1': 'value1',
+        'module.public2': 'value2'
+      })
+    })
+
+    it('should return empty object when no public attributes exist', () => {
+      instance._config = { 'module.private': 'secret' }
+      instance.publicAttributes = []
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {})
+    })
+
+    it('should handle undefined values for public attributes', () => {
+      instance._config = {}
+      instance.publicAttributes = ['module.missing']
+
+      const config = instance.getPublicConfig()
+      assert.deepEqual(config, {
+        'module.missing': undefined
+      })
     })
   })
 })
-/**
-* Checks ConfigUtility#initialise
-* Loads the testing data in tests/data/dirname
-*/
-function runConfigInitialise (dirname) {
-  return function () {
-    this.config.app.dependencies = [{ name: 'adapt-authoring-testing', dir: path.join(__dirname, 'data', dirname) }]
-    this.config.initialise()
-    this.config.errors.length.should.be.exactly(1)
-  }
-}

package/tests/configUtils.spec.js

@@ -1,36 +0,0 @@
-/* global describe, it */
-
-const path = require('path')
-const utils = require('../lib/ConfigUtils')
-const should = require('should')
-
-describe('Config utils', function () {
-  describe('#loadFile()', function () {
-    it('should be able to load a valid file', function () {
-      const filepath = path.join(__dirname, 'data', 'testfile.json')
-      const actualContents = utils.loadFile(filepath)
-      const expectedContents = require(filepath)
-      actualContents.should.deepEqual(expectedContents)
-    })
-    it('should not error on a missing file', function () {
-      should.doesNotThrow(function () {
-        const contents = utils.loadFile(path.join('this', 'path', 'does', 'not', 'exist.xyz'))
-        should(contents).be.undefined()
-      })
-    })
-  })
-  describe('#loadConfigSchema()', function () {
-    it('should be able to load a valid schema file', function () {
-      const dir = path.join(__dirname, 'data')
-      const actualContents = utils.loadConfigSchema(dir)
-      const expectedContents = require(path.join(dir, 'conf', 'config.schema.js'))
-      actualContents.should.deepEqual(expectedContents)
-    })
-    it('should not error on a missing schema file', function () {
-      should.doesNotThrow(function () {
-        const contents = utils.loadConfigSchema(path.join(__dirname, 'doesntexist'))
-        should(contents).be.undefined()
-      })
-    })
-  })
-})