adapt-authoring-adaptframework 1.10.2 → 1.11.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/AdaptFrameworkImport.js

@@ -708,8 +708,10 @@ class AdaptFrameworkImport {
    */
   async importCourseData () {
     const formatError = e => {
-      if (e?.data?.schemaName) return { schemaName: e.data.schemaName, id: e.data.data?._id, errors: e.data.errors }
-      return { message: App.instance.lang.translate(undefined, e) }
+      if (e?.data?.schemaName) {
+        return `${e.data.schemaName}${e.data.data?._id ? ` (${e.data.data._id})` : ''}: ${e.data.errors ?? e.message}`
+      }
+      return e?.toString() ?? String(e)
     }
     /**
      * Note: the execution order is important here

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "1.10.2",
+  "version": "1.11.0",
   "description": "Adapt framework integration for the Adapt authoring tool",
   "homepage": "https://github.com/adapt-security/adapt-authoring-adaptframework",
   "license": "GPL-3.0",
   "type": "module",
   "main": "index.js",
   "repository": "github:adapt-security/adapt-authoring-adaptframework",
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
+  },
   "dependencies": {
     "adapt-authoring-browserslist": "^1.2.1",
     "adapt-authoring-content": "^1.2.3",

package/tests/AdaptFrameworkBuild.spec.js

@@ -0,0 +1,202 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs/promises'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import AdaptFrameworkBuild from '../lib/AdaptFrameworkBuild.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+describe('AdaptFrameworkBuild', () => {
+  describe('constructor', () => {
+    it('should set action and related boolean flags for preview', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.action, 'preview')
+      assert.equal(build.isPreview, true)
+      assert.equal(build.isPublish, false)
+      assert.equal(build.isExport, false)
+    })
+
+    it('should set action and related boolean flags for publish', () => {
+      const build = new AdaptFrameworkBuild({ action: 'publish', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.isPreview, false)
+      assert.equal(build.isPublish, true)
+      assert.equal(build.isExport, false)
+    })
+
+    it('should set action and related boolean flags for export', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.isPreview, false)
+      assert.equal(build.isPublish, false)
+      assert.equal(build.isExport, true)
+    })
+
+    it('should default compress to false for preview', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.compress, false)
+    })
+
+    it('should default compress to true for publish', () => {
+      const build = new AdaptFrameworkBuild({ action: 'publish', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.compress, true)
+    })
+
+    it('should default compress to true for export', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.compress, true)
+    })
+
+    it('should allow overriding compress', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1', compress: true })
+      assert.equal(build.compress, true)
+    })
+
+    it('should set courseId and userId', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'course123', userId: 'user456' })
+      assert.equal(build.courseId, 'course123')
+      assert.equal(build.userId, 'user456')
+    })
+
+    it('should set expiresAt when provided', () => {
+      const expires = '2025-01-01T00:00:00.000Z'
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1', expiresAt: expires })
+      assert.equal(build.expiresAt, expires)
+    })
+
+    it('should initialise courseData as empty object', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      assert.deepEqual(build.courseData, {})
+    })
+
+    it('should initialise enabledPlugins and disabledPlugins as empty arrays', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      assert.deepEqual(build.enabledPlugins, [])
+      assert.deepEqual(build.disabledPlugins, [])
+    })
+
+    it('should set collectionName to "adaptbuilds"', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      assert.equal(build.collectionName, 'adaptbuilds')
+    })
+  })
+
+  describe('#ensureDir()', () => {
+    const testDir = path.join(__dirname, 'data', 'ensure-dir-test')
+    let build
+
+    before(() => {
+      build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+    })
+
+    after(async () => {
+      await fs.rm(testDir, { recursive: true, force: true })
+    })
+
+    it('should create a directory that does not exist', async () => {
+      await build.ensureDir(testDir)
+      const stat = await fs.stat(testDir)
+      assert.ok(stat.isDirectory())
+    })
+
+    it('should not throw when the directory already exists', async () => {
+      await build.ensureDir(testDir)
+      const stat = await fs.stat(testDir)
+      assert.ok(stat.isDirectory())
+    })
+  })
+
+  describe('#createIdMap()', () => {
+    it('should create a mapping of _id to _friendlyId', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      const items = [
+        { _id: 'abc', _friendlyId: 'friendly-abc' },
+        { _id: 'def', _friendlyId: 'friendly-def' }
+      ]
+      build.createIdMap(items)
+      assert.deepEqual(build.idMap, {
+        abc: 'friendly-abc',
+        def: 'friendly-def'
+      })
+    })
+
+    it('should handle items without _friendlyId', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      const items = [{ _id: 'abc' }]
+      build.createIdMap(items)
+      assert.equal(build.idMap.abc, undefined)
+    })
+  })
+
+  describe('#sortContentItems()', () => {
+    it('should sort content into correct types', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: undefined },
+        config: { dir: '/tmp', fileName: 'config.json', data: undefined },
+        contentObject: { dir: '/tmp', fileName: 'contentObjects.json', data: [] },
+        article: { dir: '/tmp', fileName: 'articles.json', data: [] },
+        block: { dir: '/tmp', fileName: 'blocks.json', data: [] },
+        component: { dir: '/tmp', fileName: 'components.json', data: [] }
+      }
+      const items = [
+        { _id: 'course1', _type: 'course' },
+        { _id: 'config1', _type: 'config' },
+        { _id: 'page1', _type: 'page', _parentId: 'course1', _sortOrder: 1 },
+        { _id: 'article1', _type: 'article', _parentId: 'page1', _sortOrder: 1 },
+        { _id: 'block1', _type: 'block', _parentId: 'article1', _sortOrder: 1 },
+        { _id: 'comp1', _type: 'component', _parentId: 'block1', _sortOrder: 1 }
+      ]
+      build.sortContentItems(items)
+
+      assert.equal(build.courseData.course.data._id, 'course1')
+      assert.equal(build.courseData.config.data._id, 'config1')
+      assert.equal(build.courseData.contentObject.data.length, 1)
+      assert.equal(build.courseData.article.data.length, 1)
+      assert.equal(build.courseData.block.data.length, 1)
+      assert.equal(build.courseData.component.data.length, 1)
+    })
+
+    it('should sort siblings by _sortOrder', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: undefined },
+        config: { dir: '/tmp', fileName: 'config.json', data: undefined },
+        contentObject: { dir: '/tmp', fileName: 'contentObjects.json', data: [] },
+        article: { dir: '/tmp', fileName: 'articles.json', data: [] },
+        block: { dir: '/tmp', fileName: 'blocks.json', data: [] },
+        component: { dir: '/tmp', fileName: 'components.json', data: [] }
+      }
+      const items = [
+        { _id: 'course1', _type: 'course' },
+        { _id: 'page2', _type: 'page', _parentId: 'course1', _sortOrder: 2 },
+        { _id: 'page1', _type: 'page', _parentId: 'course1', _sortOrder: 1 },
+        { _id: 'page3', _type: 'page', _parentId: 'course1', _sortOrder: 3 }
+      ]
+      build.sortContentItems(items)
+
+      assert.equal(build.courseData.contentObject.data[0]._id, 'page1')
+      assert.equal(build.courseData.contentObject.data[1]._id, 'page2')
+      assert.equal(build.courseData.contentObject.data[2]._id, 'page3')
+    })
+
+    it('should categorise "menu" type as contentObject', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: undefined },
+        config: { dir: '/tmp', fileName: 'config.json', data: undefined },
+        contentObject: { dir: '/tmp', fileName: 'contentObjects.json', data: [] },
+        article: { dir: '/tmp', fileName: 'articles.json', data: [] },
+        block: { dir: '/tmp', fileName: 'blocks.json', data: [] },
+        component: { dir: '/tmp', fileName: 'components.json', data: [] }
+      }
+      const items = [
+        { _id: 'course1', _type: 'course' },
+        { _id: 'menu1', _type: 'menu', _parentId: 'course1', _sortOrder: 1 }
+      ]
+      build.sortContentItems(items)
+
+      assert.equal(build.courseData.contentObject.data.length, 1)
+      assert.equal(build.courseData.contentObject.data[0]._id, 'menu1')
+    })
+  })
+})

package/tests/AdaptFrameworkImport.spec.js

@@ -0,0 +1,29 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import AdaptFrameworkImport from '../lib/AdaptFrameworkImport.js'
+
+describe('AdaptFrameworkImport', () => {
+  describe('.typeToSchema()', () => {
+    it('should return "contentobject" for menu type', () => {
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'menu' }), 'contentobject')
+    })
+
+    it('should return "contentobject" for page type', () => {
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'page' }), 'contentobject')
+    })
+
+    it('should return component-prefixed schema for component type', () => {
+      assert.equal(
+        AdaptFrameworkImport.typeToSchema({ _type: 'component', _component: 'adapt-contrib-text' }),
+        'adapt-contrib-text-component'
+      )
+    })
+
+    it('should return the _type directly for other types', () => {
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'course' }), 'course')
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'config' }), 'config')
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'article' }), 'article')
+      assert.equal(AdaptFrameworkImport.typeToSchema({ _type: 'block' }), 'block')
+    })
+  })
+})

package/tests/AdaptFrameworkUtils.spec.js

@@ -0,0 +1,163 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs/promises'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import AdaptFrameworkUtils from '../lib/AdaptFrameworkUtils.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+describe('AdaptFrameworkUtils', () => {
+  describe('#inferBuildAction()', () => {
+    const cases = [
+      { url: '/preview/abc123', expected: 'preview' },
+      { url: '/publish/abc123', expected: 'publish' },
+      { url: '/export/abc123', expected: 'export' }
+    ]
+    cases.forEach(({ url, expected }) => {
+      it(`should return "${expected}" for URL "${url}"`, () => {
+        assert.equal(AdaptFrameworkUtils.inferBuildAction({ url }), expected)
+      })
+    })
+
+    // TODO: inferBuildAction returns truncated result for URLs without a second slash
+    // e.g. '/import' returns 'impor' because indexOf('/', 1) returns -1
+    // causing slice(1, -1) to strip the last character
+    it('should truncate action for URLs without trailing slash/path (known bug)', () => {
+      assert.equal(AdaptFrameworkUtils.inferBuildAction({ url: '/import' }), 'impor')
+    })
+  })
+
+  describe('#toBoolean()', () => {
+    it('should return true for boolean true', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(true), true)
+    })
+
+    it('should return true for string "true"', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean('true'), true)
+    })
+
+    it('should return false for boolean false', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(false), false)
+    })
+
+    it('should return false for string "false"', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean('false'), false)
+    })
+
+    it('should return undefined for undefined', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(undefined), undefined)
+    })
+
+    it('should return false for null', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(null), false)
+    })
+
+    it('should return false for 0', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(0), false)
+    })
+
+    it('should return false for empty string', () => {
+      assert.equal(AdaptFrameworkUtils.toBoolean(''), false)
+    })
+  })
+
+  describe('#getPluginUpdateStatus()', () => {
+    it('should return "INVALID" for an invalid import version', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['1.0.0', 'not-valid'], false, false), 'INVALID')
+    })
+
+    it('should return "INSTALLED" when no installed version exists', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus([undefined, '1.0.0'], false, false), 'INSTALLED')
+    })
+
+    it('should return "OLDER" when import version is older', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['2.0.0', '1.0.0'], false, false), 'OLDER')
+    })
+
+    it('should return "NO_CHANGE" when versions are equal', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['1.0.0', '1.0.0'], false, false), 'NO_CHANGE')
+    })
+
+    it('should return "UPDATE_BLOCKED" when import is newer but updates not enabled and not local', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['1.0.0', '2.0.0'], false, false), 'UPDATE_BLOCKED')
+    })
+
+    it('should return "UPDATED" when import is newer and updates are enabled', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['1.0.0', '2.0.0'], false, true), 'UPDATED')
+    })
+
+    it('should return "UPDATED" when import is newer and is a local install', () => {
+      assert.equal(AdaptFrameworkUtils.getPluginUpdateStatus(['1.0.0', '2.0.0'], true, false), 'UPDATED')
+    })
+  })
+
+  describe('#getImportContentCounts()', () => {
+    it('should count single items by _type', () => {
+      const content = {
+        course: { _type: 'course' },
+        config: { _type: 'config' }
+      }
+      const result = AdaptFrameworkUtils.getImportContentCounts(content)
+      assert.deepEqual(result, { course: 1, config: 1 })
+    })
+
+    it('should count arrays of items by _type', () => {
+      const content = {
+        course: { _type: 'course' },
+        contentObjects: {
+          co1: { _type: 'page' },
+          co2: { _type: 'page' },
+          co3: { _type: 'menu' }
+        }
+      }
+      const result = AdaptFrameworkUtils.getImportContentCounts(content)
+      assert.deepEqual(result, { course: 1, page: 2, menu: 1 })
+    })
+
+    it('should return empty object for empty content', () => {
+      assert.deepEqual(AdaptFrameworkUtils.getImportContentCounts({}), {})
+    })
+  })
+
+  describe('#readJson()', () => {
+    const testFile = path.join(__dirname, 'data', 'test-read.json')
+
+    before(async () => {
+      await fs.mkdir(path.join(__dirname, 'data'), { recursive: true })
+      await fs.writeFile(testFile, JSON.stringify({ key: 'value' }))
+    })
+
+    after(async () => {
+      await fs.rm(testFile, { force: true })
+    })
+
+    it('should read and parse a JSON file', async () => {
+      const result = await AdaptFrameworkUtils.readJson(testFile)
+      assert.deepEqual(result, { key: 'value' })
+    })
+
+    it('should throw for a non-existent file', async () => {
+      await assert.rejects(
+        AdaptFrameworkUtils.readJson('/nonexistent/file.json'),
+        { code: 'ENOENT' }
+      )
+    })
+  })
+
+  describe('#writeJson()', () => {
+    const testFile = path.join(__dirname, 'data', 'test-write.json')
+
+    after(async () => {
+      await fs.rm(testFile, { force: true })
+    })
+
+    it('should write formatted JSON to a file', async () => {
+      const data = { hello: 'world', num: 42 }
+      await AdaptFrameworkUtils.writeJson(testFile, data)
+      const content = await fs.readFile(testFile, 'utf8')
+      assert.deepEqual(JSON.parse(content), data)
+      assert.ok(content.includes('\n'), 'should be formatted with indentation')
+    })
+  })
+})