adapt-authoring-ui 1.8.6 → 1.9.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@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/lib/UiBuild.js

@@ -60,7 +60,7 @@ class UiBuild {
     this.preBuildHook = new Hook()
     this.postBuildHook = new Hook()
 
-    this.jsTask = new JavaScriptTask(this.Paths.Output, this.log, this.uiPlugins, this.app.getConfig('tempDir'))
+    this.jsTask = new JavaScriptTask(this.Paths.Output, this.log, this.uiPlugins, path.join(this.app.getConfig('tempDir'), 'ui-build-cache'))
   }
 
   collate (collateAtFolderName, destFolder, srcFileName) {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "adapt-authoring-ui",
-  "version": "1.8.6",
+  "version": "1.9.0",
   "description": "Front-end application for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-ui",
   "license": "GPL-3.0",
   "type": "module",
   "main": "index.js",
   "scripts": {
-    "postinstall": "node npm_hooks/postinstall.js"
+    "postinstall": "node npm_hooks/postinstall.js",
+    "test": "node --test 'tests/**/*.spec.js'"
   },
   "repository": "github:adapt-security/adapt-authoring-ui",
   "dependencies": {

package/tests/CacheManager.spec.js

@@ -0,0 +1,170 @@
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import crypto from 'crypto'
+import os from 'os'
+import path from 'path'
+import fs from 'fs-extra'
+import CacheManager from '../lib/CacheManager.js'
+
+describe('CacheManager', () => {
+  describe('constructor', () => {
+    it('should set maxAge to the provided value', () => {
+      const cm = new CacheManager({ maxAge: 1000, logger: { log () {} } })
+      assert.equal(cm.maxAge, 1000)
+    })
+
+    it('should use ONE_WEEK as default maxAge', () => {
+      const ONE_WEEK = 7 * 24 * 60 * 60 * 1000
+      const cm = new CacheManager({ logger: { log () {} } })
+      assert.equal(cm.maxAge, ONE_WEEK)
+    })
+
+    it('should set the provided logger', () => {
+      const logger = { log () {} }
+      const cm = new CacheManager({ logger })
+      assert.equal(cm.logger, logger)
+    })
+
+    it('should use a default logger when none is provided', () => {
+      const cm = new CacheManager()
+      assert.equal(typeof cm.logger.log, 'function')
+    })
+
+    it('should use provided tempDir', () => {
+      const tempDir = path.join(os.tmpdir(), 'adapt-authoring-test-custom')
+      const cm = new CacheManager({ tempDir, logger: { log () {} } })
+      assert.equal(cm.tempDir, tempDir)
+      // Cleanup
+      try { fs.rmdirSync(tempDir) } catch (e) {}
+    })
+
+    it('should use default tempDir when none is provided', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      assert.equal(cm.tempDir, path.join(os.tmpdir(), 'adapt-authoring'))
+    })
+
+    it('should ensure tempDir directory exists', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      assert.ok(fs.existsSync(cm.tempDir))
+    })
+  })
+
+  describe('static hash', () => {
+    it('should return a SHA1 hex digest of the input', () => {
+      const input = '/some/path/to/file'
+      const expected = crypto
+        .createHash('sha1')
+        .update(input, 'utf8')
+        .digest('hex')
+      assert.equal(CacheManager.hash(input), expected)
+    })
+
+    it('should return different hashes for different inputs', () => {
+      const hash1 = CacheManager.hash('/path/one')
+      const hash2 = CacheManager.hash('/path/two')
+      assert.notEqual(hash1, hash2)
+    })
+
+    it('should return the same hash for the same input', () => {
+      const hash1 = CacheManager.hash('/same/path')
+      const hash2 = CacheManager.hash('/same/path')
+      assert.equal(hash1, hash2)
+    })
+
+    it('should return a 40-character hex string', () => {
+      const hash = CacheManager.hash('test')
+      assert.match(hash, /^[0-9a-f]{40}$/)
+    })
+  })
+
+  describe('cachePath', () => {
+    it('should return a .cache file path under tempDir', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      const result = cm.cachePath('/base', '/output')
+      assert.ok(result.startsWith(cm.tempDir))
+      assert.ok(result.endsWith('.cache'))
+    })
+
+    it('should incorporate both basePath and outputFilePath into the hash', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      const result1 = cm.cachePath('/base1', '/output')
+      const result2 = cm.cachePath('/base2', '/output')
+      assert.notEqual(result1, result2)
+    })
+
+    it('should use process.cwd() as default outputFilePath', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      const expectedHash = CacheManager.hash(path.join('/base', process.cwd()))
+      const expected = path.join(cm.tempDir, `${expectedHash}.cache`)
+      assert.equal(cm.cachePath('/base'), expected)
+    })
+
+    it('should produce a deterministic result for same inputs', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      const result1 = cm.cachePath('/base', '/output')
+      const result2 = cm.cachePath('/base', '/output')
+      assert.equal(result1, result2)
+    })
+  })
+
+  describe('checkFilePath', () => {
+    it('should return a last.touch file path under tempDir', () => {
+      const cm = new CacheManager({ logger: { log () {} } })
+      assert.equal(cm.checkFilePath, path.join(cm.tempDir, 'last.touch'))
+    })
+  })
+
+  describe('isCleaningTime', () => {
+    let cm
+
+    beforeEach(() => {
+      cm = new CacheManager({ maxAge: 1000, logger: { log () {} } })
+    })
+
+    it('should return true when checkFile does not exist', async () => {
+      const checkPath = cm.checkFilePath
+      try { fs.unlinkSync(checkPath) } catch (e) {}
+      const result = await cm.isCleaningTime()
+      assert.equal(result, true)
+    })
+
+    it('should return false when checkFile was just created', async () => {
+      const checkPath = cm.checkFilePath
+      fs.writeFileSync(checkPath, String(Date.now()))
+      const result = await cm.isCleaningTime()
+      assert.equal(result, false)
+    })
+  })
+
+  describe('clean', () => {
+    let cm
+
+    beforeEach(() => {
+      // Use a large maxAge so the checkFile is not treated as expired
+      cm = new CacheManager({ maxAge: 7 * 24 * 60 * 60 * 1000, logger: { log () {} } })
+      fs.ensureDirSync(cm.tempDir)
+      // Remove checkFile to ensure cleaning happens
+      try { fs.unlinkSync(cm.checkFilePath) } catch (e) {}
+    })
+
+    it('should create checkFile after cleaning', async () => {
+      await cm.clean()
+      assert.ok(fs.existsSync(cm.checkFilePath))
+    })
+
+    it('should not clean when it is not cleaning time', async () => {
+      // First write the checkFile so it appears fresh
+      fs.writeFileSync(cm.checkFilePath, String(Date.now()))
+      // Set a long maxAge so checkInterval is large
+      cm.maxAge = 7 * 24 * 60 * 60 * 1000
+      // Create a test file
+      const testFile = path.join(cm.tempDir, 'test-no-clean.cache')
+      fs.writeFileSync(testFile, 'data')
+      await cm.clean()
+      // File should still exist since it is not cleaning time
+      assert.ok(fs.existsSync(testFile))
+      // Cleanup
+      try { fs.unlinkSync(testFile) } catch (e) {}
+    })
+  })
+})

package/tests/JavaScriptTask.spec.js

@@ -0,0 +1,247 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs-extra'
+
+/**
+ * JavaScriptTask depends on rollup, babel, glob, fs-extra and other heavy
+ * build dependencies. We test the pure utility methods in isolation by
+ * reimplementing them with the same logic.
+ */
+
+/**
+ * Reimplementation of JavaScriptTask.prototype.escapeRegExp for isolated testing.
+ */
+function escapeRegExp (string) {
+  return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&')
+}
+
+describe('JavaScriptTask', () => {
+  describe('escapeRegExp', () => {
+    it('should escape dots', () => {
+      assert.equal(escapeRegExp('file.js'), 'file\\.js')
+    })
+
+    it('should escape asterisks', () => {
+      assert.equal(escapeRegExp('**/*.js'), '\\*\\*/\\*\\.js')
+    })
+
+    it('should escape plus signs', () => {
+      assert.equal(escapeRegExp('a+b'), 'a\\+b')
+    })
+
+    it('should escape question marks', () => {
+      assert.equal(escapeRegExp('file?.js'), 'file\\?\\.js')
+    })
+
+    it('should escape caret', () => {
+      assert.equal(escapeRegExp('^start'), '\\^start')
+    })
+
+    it('should escape dollar sign', () => {
+      assert.equal(escapeRegExp('end$'), 'end\\$')
+    })
+
+    it('should escape curly braces', () => {
+      assert.equal(escapeRegExp('{a,b}'), '\\{a,b\\}')
+    })
+
+    it('should escape parentheses', () => {
+      assert.equal(escapeRegExp('(group)'), '\\(group\\)')
+    })
+
+    it('should escape pipe', () => {
+      assert.equal(escapeRegExp('a|b'), 'a\\|b')
+    })
+
+    it('should escape square brackets', () => {
+      assert.equal(escapeRegExp('[abc]'), '\\[abc\\]')
+    })
+
+    it('should escape backslashes', () => {
+      assert.equal(escapeRegExp('path\\to'), 'path\\\\to')
+    })
+
+    it('should escape hyphen/minus', () => {
+      assert.equal(escapeRegExp('a-b'), 'a\\-b')
+    })
+
+    it('should return the same string if no special chars', () => {
+      assert.equal(escapeRegExp('hello world'), 'hello world')
+    })
+
+    it('should handle empty string', () => {
+      assert.equal(escapeRegExp(''), '')
+    })
+
+    it('should handle multiple special characters together', () => {
+      const input = 'C:\\Users\\test\\file.js'
+      const expected = 'C:\\\\Users\\\\test\\\\file\\.js'
+      assert.equal(escapeRegExp(input), expected)
+    })
+
+    it('should produce a string usable in new RegExp without error', () => {
+      const special = 'path/to/file.*(test)+[0]'
+      const escaped = escapeRegExp(special)
+      assert.doesNotThrow(() => new RegExp(escaped))
+    })
+
+    it('should produce a regex that matches the original string literally', () => {
+      const special = 'hello.world+foo*bar'
+      const escaped = escapeRegExp(special)
+      const regex = new RegExp(escaped)
+      assert.ok(regex.test(special))
+    })
+  })
+
+  describe('checkCache', () => {
+    /**
+     * Reimplementation of JavaScriptTask.prototype.checkCache for isolated testing.
+     * Uses a context object instead of `this`.
+     */
+    function checkCache (context, invalidate) {
+      if (!context.cache) return
+      const idHash = {}
+      const missing = {}
+      context.cache.modules.forEach(mod => {
+        const moduleId = mod.id
+        const isRollupHelper = (moduleId[0] === '\u0000')
+        if (isRollupHelper) {
+          return null
+        }
+        if (!fs.existsSync(moduleId)) {
+          context.log('error', `Cache missing file: ${moduleId.replace(context.cwd, '')}`)
+          missing[moduleId] = true
+          return false
+        }
+        if (invalidate && invalidate.includes(moduleId)) {
+          context.log('debug', `Cache skipping file: ${moduleId.replace(context.cwd, '')}`)
+          return false
+        }
+        idHash[moduleId] = mod
+        return true
+      })
+      if (Object.keys(missing).length) {
+        context.cache = null
+        return
+      }
+      context.cache.modules = Object.values(idHash)
+    }
+
+    it('should return early when cache is null', () => {
+      const context = { cache: null, log () {} }
+      checkCache(context, [])
+      assert.equal(context.cache, null)
+    })
+
+    it('should clear cache when a module file is missing', () => {
+      const context = {
+        cache: {
+          modules: [
+            { id: '/nonexistent/path/to/module.js' }
+          ]
+        },
+        cwd: process.cwd() + '/',
+        log () {}
+      }
+      checkCache(context, [])
+      assert.equal(context.cache, null)
+    })
+
+    it('should skip rollup helper modules (prefixed with null char)', () => {
+      // Create a real file so the non-helper module passes the existsSync check
+      const existingFile = import.meta.url.replace('file://', '').replace(/\/[^/]+$/, '/JavaScriptTask.spec.js')
+      const context = {
+        cache: {
+          modules: [
+            { id: '\u0000rollupHelper' },
+            { id: existingFile }
+          ]
+        },
+        cwd: '',
+        log () {}
+      }
+      checkCache(context, [])
+      // Cache should not be null since the real file exists
+      assert.notEqual(context.cache, null)
+      // Only the real file should remain (rollup helper is skipped, not added to idHash)
+      assert.equal(context.cache.modules.length, 1)
+      assert.equal(context.cache.modules[0].id, existingFile)
+    })
+
+    it('should remove invalidated modules from cache', () => {
+      const existingFile = import.meta.url.replace('file://', '').replace(/\/[^/]+$/, '/JavaScriptTask.spec.js')
+      const context = {
+        cache: {
+          modules: [
+            { id: existingFile }
+          ]
+        },
+        cwd: '',
+        log () {}
+      }
+      checkCache(context, [existingFile])
+      assert.notEqual(context.cache, null)
+      assert.equal(context.cache.modules.length, 0)
+    })
+
+    it('should keep valid non-invalidated modules', () => {
+      const existingFile = import.meta.url.replace('file://', '').replace(/\/[^/]+$/, '/JavaScriptTask.spec.js')
+      const context = {
+        cache: {
+          modules: [
+            { id: existingFile }
+          ]
+        },
+        cwd: '',
+        log () {}
+      }
+      checkCache(context, [])
+      assert.notEqual(context.cache, null)
+      assert.equal(context.cache.modules.length, 1)
+    })
+  })
+
+  describe('logPrettyError', () => {
+    it('should handle errors with loc and babel plugin', () => {
+      const err = new Error('babel: Unexpected token\n  1 | code here\n    | ^')
+      err.loc = { line: 1, column: 5 }
+      err.plugin = 'babel'
+      err.id = '/Users/test/project/src/file.js'
+
+      // Extract babel error handling logic from logPrettyError
+      err.frame = err.message.substr(err.message.indexOf('\n') + 1)
+      err.message = err.message.substr(0, err.message.indexOf('\n')).slice(2).replace(/^([^:]*): /, '')
+
+      assert.equal(err.message, 'Unexpected token')
+      assert.ok(err.frame.includes('code here'))
+    })
+
+    it('should handle errors without loc property', () => {
+      const err = new Error('Generic build error')
+      const hasLoc = Boolean(err.loc)
+      assert.equal(hasLoc, false)
+    })
+
+    it('should handle errors with loc but non-babel plugin', () => {
+      const logged = []
+      const log = (level, ...args) => logged.push({ level, args })
+      const err = new Error('Some plugin error')
+      err.loc = { line: 5, column: 10 }
+      err.plugin = 'other-plugin'
+      err.id = '/test/src/file.js'
+
+      // Non-babel plugin path logs err.toString() in the default case
+      let hasOutput = false
+      switch (err.plugin) {
+        case 'babel':
+          break
+        default:
+          hasOutput = true
+          log('error', err.toString())
+      }
+      assert.equal(hasOutput, true)
+      assert.equal(logged.length, 1)
+      assert.equal(logged[0].level, 'error')
+    })
+  })
+})

package/tests/UiBuild.spec.js

@@ -0,0 +1,51 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import path from 'upath'
+
+/**
+ * UiBuild depends on the full app context (adapt-authoring-core Hook, app object,
+ * gaze, rollup, etc.). We extract and test the pure utility methods in isolation
+ * by reimplementing them with the same logic as UiBuild.prototype methods.
+ */
+
+/**
+ * Reimplementation of UiBuild.prototype.collate for isolated testing.
+ * Computes an output path from a collateAtFolderName, destFolder, and srcFileName.
+ */
+function collate (collateAtFolderName, destFolder, srcFileName) {
+  const nameParts = srcFileName.split('/')
+  if (nameParts[nameParts.length - 1] === collateAtFolderName) {
+    return destFolder
+  }
+  const startOfCollatePath = srcFileName.indexOf(collateAtFolderName) + collateAtFolderName.length + 1
+  return path.join(destFolder, srcFileName.substr(startOfCollatePath))
+}
+
+describe('UiBuild', () => {
+  describe('collate', () => {
+    it('should return destFolder when srcFileName ends with collateAtFolderName', () => {
+      const result = collate('assets', '/output/assets', 'some/path/assets')
+      assert.equal(result, '/output/assets')
+    })
+
+    it('should extract the path after collateAtFolderName and join with destFolder', () => {
+      const result = collate('assets', '/output/assets', 'some/path/assets/images/logo.png')
+      assert.equal(result, '/output/assets/images/logo.png')
+    })
+
+    it('should handle nested folder structures correctly', () => {
+      const result = collate('required', '/build', 'app/core/required/config.json')
+      assert.equal(result, '/build/config.json')
+    })
+
+    it('should handle deeply nested paths after collateAtFolderName', () => {
+      const result = collate('libraries', '/out/libs', 'app/libraries/vendor/jquery/jquery.min.js')
+      assert.equal(result, '/out/libs/vendor/jquery/jquery.min.js')
+    })
+
+    it('should handle single file after collateAtFolderName', () => {
+      const result = collate('assets', '/dest', 'module/assets/file.txt')
+      assert.equal(result, '/dest/file.txt')
+    })
+  })
+})