adapt-authoring-adaptframework 1.10.3 → 1.12.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/package.json

@@ -1,12 +1,15 @@
 {
   "name": "adapt-authoring-adaptframework",
-  "version": "1.10.3",
+  "version": "1.12.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,450 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import _ from 'lodash'
+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))
+
+/**
+ * transformContentItems is async and calls App.instance.waitForModule('tags')
+ * at the end. We extract the synchronous logic here to test it in isolation.
+ */
+function transformContentItemsSync (build, items) {
+  items.forEach(i => {
+    ['_courseId', '_parentId'].forEach(k => {
+      i[k] = build.idMap[i[k]] || i[k]
+    })
+    if (i._friendlyId) {
+      i._id = i._friendlyId
+    }
+    const idMapEntries = Object.entries(build.assetData.idMap)
+    const itemString = idMapEntries.reduce((s, [_id, assetPath]) => {
+      const relPath = assetPath.replace(build.courseDir, 'course')
+      return s.replace(new RegExp(_id, 'g'), relPath)
+    }, JSON.stringify(i))
+    Object.assign(i, JSON.parse(itemString))
+    if (i._component) {
+      i._component = build.enabledPlugins.find(p => p.name === i._component)?.targetAttribute.slice(1) ?? i._component
+    }
+  })
+  build.enabledPlugins.forEach(({ targetAttribute, type }) => {
+    let key = `_${type}`
+    if (type === 'component' || type === 'extension') key += 's'
+    const globals = build.courseData.course.data._globals
+    if (!globals?.[targetAttribute]) return
+    _.merge(globals, { [key]: { [targetAttribute]: globals[targetAttribute] } })
+    delete globals[targetAttribute]
+  })
+}
+
+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')
+    })
+
+    it('should sort deeply nested content in global order', () => {
+      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: 'page1', _type: 'page', _parentId: 'course1', _sortOrder: 1 },
+        { _id: 'page2', _type: 'page', _parentId: 'course1', _sortOrder: 2 },
+        { _id: 'art1', _type: 'article', _parentId: 'page1', _sortOrder: 1 },
+        { _id: 'art2', _type: 'article', _parentId: 'page2', _sortOrder: 1 },
+        { _id: 'art3', _type: 'article', _parentId: 'page1', _sortOrder: 2 }
+      ]
+      build.sortContentItems(items)
+
+      const articleIds = build.courseData.article.data.map(a => a._id)
+      assert.equal(articleIds[0], 'art1')
+      assert.equal(articleIds[1], 'art3')
+      assert.equal(articleIds[2], 'art2')
+    })
+  })
+
+  describe('#transformContentItems()', () => {
+    it('should replace _courseId and _parentId with friendlyIds from idMap', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = { course1: 'co-friendly', page1: 'page-friendly' }
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [
+        { _courseId: 'course1', _parentId: 'page1' }
+      ]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._courseId, 'co-friendly')
+      assert.equal(items[0]._parentId, 'page-friendly')
+    })
+
+    it('should replace _id with _friendlyId when present', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _id: 'abc', _friendlyId: 'my-friendly' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._id, 'my-friendly')
+    })
+
+    it('should not replace _id when _friendlyId is absent', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _id: 'abc' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._id, 'abc')
+    })
+
+    it('should replace asset _ids with relative paths', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.courseDir = '/build/course'
+      build.assetData = { idMap: { asset123: '/build/course/assets/image.png' } }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ graphic: 'asset123' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0].graphic, 'course/assets/image.png')
+    })
+
+    it('should resolve _component to targetAttribute', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-text', targetAttribute: '_text', type: 'component' }
+      ]
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _component: 'adapt-contrib-text' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._component, 'text')
+    })
+
+    it('should keep _component as-is when plugin not found', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _component: 'unknown-plugin' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._component, 'unknown-plugin')
+    })
+
+    it('should move globals into nested _extensions object', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-trickle', targetAttribute: '_trickle', type: 'extension' }
+      ]
+      build.courseData = {
+        course: {
+          dir: '/tmp',
+          data: {
+            _globals: {
+              _trickle: { label: 'Trickle' }
+            }
+          }
+        }
+      }
+
+      transformContentItemsSync(build, [])
+      const globals = build.courseData.course.data._globals
+      assert.equal(globals._extensions._trickle.label, 'Trickle')
+      assert.equal(globals._trickle, undefined)
+    })
+
+    it('should use _components key for component type globals', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = [
+        { name: 'adapt-contrib-text', targetAttribute: '_text', type: 'component' }
+      ]
+      build.courseData = {
+        course: {
+          dir: '/tmp',
+          data: {
+            _globals: {
+              _text: { ariaRegion: 'Text' }
+            }
+          }
+        }
+      }
+
+      transformContentItemsSync(build, [])
+      const globals = build.courseData.course.data._globals
+      assert.equal(globals._components._text.ariaRegion, 'Text')
+    })
+
+    it('should keep _courseId as-is when not in idMap', () => {
+      const build = new AdaptFrameworkBuild({ action: 'preview', courseId: 'c1', userId: 'u1' })
+      build.idMap = {}
+      build.assetData = { idMap: {} }
+      build.enabledPlugins = []
+      build.courseData = { course: { dir: '/tmp', data: {} } }
+
+      const items = [{ _courseId: 'unmapped' }]
+      transformContentItemsSync(build, items)
+      assert.equal(items[0]._courseId, 'unmapped')
+    })
+  })
+
+  describe('#writeContentJson() asset mapping', () => {
+    it('should map asset data to export format for export builds', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = {
+        data: [
+          { title: 'Logo', description: 'A logo', path: 'assets/logo.png', tags: ['branding'], _id: '123', url: '' },
+          { title: 'Icon', description: 'An icon', path: 'assets/icon.svg', tags: [], _id: '456', url: '' }
+        ]
+      }
+      /* simulate the mapping logic from writeContentJson */
+      const mapped = build.assetData.data.map(d => ({
+        title: d.title,
+        description: d.description,
+        filename: d.path,
+        tags: d.tags
+      }))
+      assert.equal(mapped.length, 2)
+      assert.equal(mapped[0].filename, 'assets/logo.png')
+      assert.equal(mapped[0].title, 'Logo')
+      assert.equal(mapped[0]._id, undefined)
+      assert.deepEqual(mapped[1].tags, [])
+    })
+
+    it('should not include assets for export when assetData is empty', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = { data: [] }
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: {} }
+      }
+      const data = Object.values(build.courseData)
+      if (build.isExport && build.assetData.data.length) {
+        data.push(build.assetData)
+      }
+      assert.equal(data.length, 1)
+    })
+
+    it('should include asset data entry for non-empty export', () => {
+      const build = new AdaptFrameworkBuild({ action: 'export', courseId: 'c1', userId: 'u1' })
+      build.assetData = { data: [{ title: 'img', path: 'a.png' }] }
+      build.courseData = {
+        course: { dir: '/tmp', fileName: 'course.json', data: {} }
+      }
+      const data = Object.values(build.courseData)
+      if (build.isExport && build.assetData.data.length) {
+        data.push(build.assetData)
+      }
+      assert.equal(data.length, 2)
+    })
+  })
+})

package/tests/AdaptFrameworkImport.spec.js

@@ -0,0 +1,327 @@
+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')
+    })
+  })
+
+  describe('#getSortedData()', () => {
+    const getSortedData = AdaptFrameworkImport.prototype.getSortedData
+
+    it('should sort a simple course hierarchy into levels', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' },
+            block1: { _id: 'block1', _parentId: 'art1' }
+          }
+        }
+      }
+      const { sorted, hierarchy } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 3)
+      assert.deepEqual(sorted[0], ['page1'])
+      assert.deepEqual(sorted[1], ['art1'])
+      assert.deepEqual(sorted[2], ['block1'])
+      assert.ok(hierarchy)
+    })
+
+    it('should group siblings at the same level', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            page2: { _id: 'page2', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' },
+            art2: { _id: 'art2', _parentId: 'page2' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 2)
+      assert.equal(sorted[0].length, 2)
+      assert.ok(sorted[0].includes('page1'))
+      assert.ok(sorted[0].includes('page2'))
+      assert.equal(sorted[1].length, 2)
+      assert.ok(sorted[1].includes('art1'))
+      assert.ok(sorted[1].includes('art2'))
+    })
+
+    it('should not include course in the sorted output', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      const allIds = sorted.flat()
+      assert.ok(!allIds.includes('course1'))
+    })
+
+    it('should build correct hierarchy map', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'course1' },
+          contentObjects: {
+            page1: { _id: 'page1', _parentId: 'course1' },
+            page2: { _id: 'page2', _parentId: 'course1' },
+            art1: { _id: 'art1', _parentId: 'page1' }
+          }
+        }
+      }
+      const { hierarchy } = getSortedData.call(ctx)
+      assert.deepEqual(hierarchy.course1, ['page1', 'page2'])
+      assert.deepEqual(hierarchy.page1, ['art1'])
+    })
+
+    it('should handle deep nesting (5 levels)', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'c' },
+          contentObjects: {
+            p: { _id: 'p', _parentId: 'c' },
+            a: { _id: 'a', _parentId: 'p' },
+            b: { _id: 'b', _parentId: 'a' },
+            x: { _id: 'x', _parentId: 'b' },
+            y: { _id: 'y', _parentId: 'x' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 5)
+      assert.deepEqual(sorted[0], ['p'])
+      assert.deepEqual(sorted[1], ['a'])
+      assert.deepEqual(sorted[2], ['b'])
+      assert.deepEqual(sorted[3], ['x'])
+      assert.deepEqual(sorted[4], ['y'])
+    })
+
+    it('should handle a single page', () => {
+      const ctx = {
+        contentJson: {
+          course: { _id: 'c' },
+          contentObjects: {
+            p: { _id: 'p', _parentId: 'c' }
+          }
+        }
+      }
+      const { sorted } = getSortedData.call(ctx)
+      assert.equal(sorted.length, 1)
+      assert.deepEqual(sorted[0], ['p'])
+    })
+  })
+
+  describe('#extractAssets()', () => {
+    function makeCtx (assetMap) {
+      const ctx = { assetMap }
+      ctx.extractAssets = AdaptFrameworkImport.prototype.extractAssets.bind(ctx)
+      return ctx
+    }
+
+    it('should replace asset paths with mapped IDs', () => {
+      const ctx = makeCtx({ 'course/en/assets/logo.png': 'asset123' })
+      const schema = {
+        _graphic: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+      const data = { _graphic: { src: 'course/en/assets/logo.png' } }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._graphic.src, 'asset123')
+    })
+
+    it('should delete empty string asset values', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        _graphic: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+      const data = { _graphic: { src: '' } }
+      ctx.extractAssets(schema, data)
+      assert.equal('src' in data._graphic, false)
+    })
+
+    it('should keep value when not in assetMap', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        img: { _backboneForms: { type: 'Asset' } }
+      }
+      const data = { img: 'unknown/path.png' }
+      ctx.extractAssets(schema, data)
+      assert.equal(data.img, 'unknown/path.png')
+    })
+
+    it('should recurse into nested properties', () => {
+      const ctx = makeCtx({ 'assets/bg.jpg': 'asset456' })
+      const schema = {
+        _settings: {
+          properties: {
+            _background: {
+              properties: {
+                src: { _backboneForms: 'Asset' }
+              }
+            }
+          }
+        }
+      }
+      const data = { _settings: { _background: { src: 'assets/bg.jpg' } } }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._settings._background.src, 'asset456')
+    })
+
+    it('should recurse into array items', () => {
+      const ctx = makeCtx({ 'assets/a.png': 'id1', 'assets/b.png': 'id2' })
+      const schema = {
+        _items: {
+          items: {
+            properties: {
+              src: { _backboneForms: 'Asset' }
+            }
+          }
+        }
+      }
+      const data = {
+        _items: [
+          { src: 'assets/a.png' },
+          { src: 'assets/b.png' }
+        ]
+      }
+      ctx.extractAssets(schema, data)
+      assert.equal(data._items[0].src, 'id1')
+      assert.equal(data._items[1].src, 'id2')
+    })
+
+    it('should skip undefined data keys', () => {
+      const ctx = makeCtx({})
+      const schema = {
+        _graphic: { _backboneForms: 'Asset' }
+      }
+      const data = {}
+      ctx.extractAssets(schema, data)
+      assert.equal('_graphic' in data, false)
+    })
+
+    it('should handle null schema gracefully', () => {
+      const ctx = makeCtx({})
+      ctx.extractAssets(null, { a: 1 })
+    })
+
+    it('should handle _backboneForms as object with type', () => {
+      const ctx = makeCtx({ 'path/img.png': 'mapped' })
+      const schema = {
+        hero: { _backboneForms: { type: 'Asset' } }
+      }
+      const data = { hero: 'path/img.png' }
+      ctx.extractAssets(schema, data)
+      assert.equal(data.hero, 'mapped')
+    })
+  })
+
+  describe('#loadContentFile()', () => {
+    /**
+     * loadContentFile depends on FWUtils.readJson (file I/O) and App.instance,
+     * but we can test the classification logic by providing a mock.
+     * We extract and test the classification behaviour inline.
+     */
+    it('should classify course type into contentJson.course', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify({ _type: 'course', title: 'My Course' }, 'en/course.json', ctx)
+      assert.equal(ctx.contentJson.course.title, 'My Course')
+    })
+
+    it('should classify config.json as config with defaults', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify({ _defaultLanguage: 'en' }, 'course/config.json', ctx)
+      assert.equal(ctx.contentJson.config._id, 'config')
+      assert.equal(ctx.contentJson.config._type, 'config')
+      assert.equal(ctx.contentJson.config._defaultLanguage, 'en')
+    })
+
+    it('should store array contents into contentObjects by _id', () => {
+      const classify = (contents, filePath, ctx) => {
+        if (contents._type === 'course') {
+          ctx.contentJson.course = contents
+          return
+        }
+        if (filePath.endsWith('config.json')) {
+          ctx.contentJson.config = { _id: 'config', _type: 'config', ...contents }
+          return
+        }
+        if (Array.isArray(contents)) {
+          contents.forEach(c => {
+            ctx.contentJson.contentObjects[c._id] = c
+          })
+        }
+      }
+      const ctx = { contentJson: { course: {}, config: {}, contentObjects: {} } }
+      classify([
+        { _id: 'page1', _type: 'page' },
+        { _id: 'art1', _type: 'article' }
+      ], 'en/contentObjects.json', ctx)
+      assert.equal(ctx.contentJson.contentObjects.page1._type, 'page')
+      assert.equal(ctx.contentJson.contentObjects.art1._type, 'article')
+    })
+  })
+})

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')
+    })
+  })
+})

package/tests/migrations.spec.js

@@ -0,0 +1,394 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import ConfigTransform from '../lib/migrations/config.js'
+import GraphicSrcTransform from '../lib/migrations/graphic-src.js'
+import NavOrderTransform from '../lib/migrations/nav-order.js'
+import ParentIdTransform from '../lib/migrations/parent-id.js'
+import RemoveUndef from '../lib/migrations/remove-undef.js'
+import StartPage from '../lib/migrations/start-page.js'
+import ThemeUndef from '../lib/migrations/theme-undef.js'
+
+describe('Migrations', () => {
+  describe('ConfigTransform', () => {
+    it('should convert numeric ARIA levels to strings', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: {
+          _ariaLevels: {
+            _menu: 1,
+            _menuItem: 2,
+            _page: 3,
+            _article: 4,
+            _block: 5,
+            _component: 6,
+            _componentItem: 7,
+            _notify: 8
+          }
+        }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, '1')
+      assert.equal(data._accessibility._ariaLevels._menuItem, '2')
+      assert.equal(data._accessibility._ariaLevels._page, '3')
+      assert.equal(data._accessibility._ariaLevels._article, '4')
+      assert.equal(data._accessibility._ariaLevels._block, '5')
+      assert.equal(data._accessibility._ariaLevels._component, '6')
+      assert.equal(data._accessibility._ariaLevels._componentItem, '7')
+      assert.equal(data._accessibility._ariaLevels._notify, '8')
+    })
+
+    it('should not modify already-string values', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: { _ariaLevels: { _menu: '1' } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, '1')
+    })
+
+    it('should skip non-config types', async () => {
+      const data = {
+        _type: 'course',
+        _accessibility: { _ariaLevels: { _menu: 1 } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, 1)
+    })
+
+    it('should skip config without _ariaLevels', async () => {
+      const data = { _type: 'config', _accessibility: {} }
+      await ConfigTransform(data)
+      assert.deepEqual(data._accessibility, {})
+    })
+
+    it('should not convert falsy values (0)', async () => {
+      const data = {
+        _type: 'config',
+        _accessibility: { _ariaLevels: { _menu: 0 } }
+      }
+      await ConfigTransform(data)
+      assert.equal(data._accessibility._ariaLevels._menu, 0)
+    })
+  })
+
+  describe('GraphicSrcTransform', () => {
+    it('should copy src to large and small for graphic component', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { src: 'image.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'image.png')
+      assert.equal(data._graphic.small, 'image.png')
+    })
+
+    it('should copy src to large and small for hotgraphic component', async () => {
+      const data = {
+        _component: 'adapt-contrib-hotgraphic',
+        _graphic: { src: 'hot.png' },
+        _items: [
+          { _graphic: { src: 'item1.png' } },
+          { _graphic: { src: 'item2.png' } }
+        ]
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'hot.png')
+      assert.equal(data._graphic.small, 'hot.png')
+      assert.equal(data._items[0]._graphic.large, 'item1.png')
+      assert.equal(data._items[0]._graphic.small, 'item1.png')
+      assert.equal(data._items[1]._graphic.large, 'item2.png')
+      assert.equal(data._items[1]._graphic.small, 'item2.png')
+    })
+
+    it('should skip non-graphic components', async () => {
+      const data = {
+        _component: 'adapt-contrib-text',
+        _graphic: { src: 'image.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, undefined)
+    })
+
+    it('should not overwrite if src is absent', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { large: 'existing.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'existing.png')
+    })
+
+    it('should handle graphic without _items', async () => {
+      const data = {
+        _component: 'adapt-contrib-graphic',
+        _graphic: { src: 'only.png' }
+      }
+      await GraphicSrcTransform(data)
+      assert.equal(data._graphic.large, 'only.png')
+      assert.equal(data._graphic.small, 'only.png')
+    })
+  })
+
+  describe('NavOrderTransform', () => {
+    it('should convert string _navOrder to number', async () => {
+      const data = {
+        _type: 'course',
+        _globals: {
+          _extensions: {
+            _trickle: { _navOrder: '100' },
+            _resources: { _navOrder: '200' }
+          }
+        }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, 100)
+      assert.equal(data._globals._extensions._resources._navOrder, 200)
+    })
+
+    it('should keep numeric _navOrder as-is', async () => {
+      const data = {
+        _type: 'course',
+        _globals: { _extensions: { _trickle: { _navOrder: 50 } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, 50)
+    })
+
+    it('should skip non-course types', async () => {
+      const data = {
+        _type: 'config',
+        _globals: { _extensions: { _trickle: { _navOrder: '100' } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, '100')
+    })
+
+    it('should skip extensions without _navOrder', async () => {
+      const data = {
+        _type: 'course',
+        _globals: { _extensions: { _trickle: { other: 'value' } } }
+      }
+      await NavOrderTransform(data)
+      assert.equal(data._globals._extensions._trickle._navOrder, undefined)
+    })
+  })
+
+  describe('ParentIdTransform', () => {
+    it('should remap _parentId using idMap', async () => {
+      const data = { _parentId: 'old-id' }
+      const importer = { idMap: { 'old-id': 'new-id' } }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, 'new-id')
+    })
+
+    it('should set _parentId to undefined when not in idMap', async () => {
+      const data = { _parentId: 'unknown' }
+      const importer = { idMap: {} }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+
+    it('should skip when _parentId is falsy', async () => {
+      const data = { _parentId: undefined }
+      const importer = { idMap: { undefined: 'should-not-set' } }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+
+    it('should skip when _parentId is not present', async () => {
+      const data = { _type: 'course' }
+      const importer = { idMap: {} }
+      await ParentIdTransform(data, importer)
+      assert.equal(data._parentId, undefined)
+    })
+  })
+
+  describe('RemoveUndef', () => {
+    it('should remove null properties', async () => {
+      const data = { a: 1, b: null, c: 'test' }
+      await RemoveUndef(data)
+      assert.equal(data.a, 1)
+      assert.equal(data.c, 'test')
+      assert.equal('b' in data, false)
+    })
+
+    it('should recursively remove nulls in nested objects', async () => {
+      const data = { a: { b: null, c: { d: null, e: 1 } } }
+      await RemoveUndef(data)
+      assert.equal('b' in data.a, false)
+      assert.equal('d' in data.a.c, false)
+      assert.equal(data.a.c.e, 1)
+    })
+
+    it('should not recurse into arrays', async () => {
+      const data = { arr: [null, 1, null] }
+      await RemoveUndef(data)
+      assert.deepEqual(data.arr, [null, 1, null])
+    })
+
+    it('should preserve non-null falsy values', async () => {
+      const data = { a: 0, b: false, c: '', d: undefined }
+      await RemoveUndef(data)
+      assert.equal(data.a, 0)
+      assert.equal(data.b, false)
+      assert.equal(data.c, '')
+      assert.equal(data.d, undefined)
+    })
+
+    it('should handle empty object', async () => {
+      const data = {}
+      await RemoveUndef(data)
+      assert.deepEqual(data, {})
+    })
+
+    it('should handle deeply nested nulls', async () => {
+      const data = { a: { b: { c: { d: null } } } }
+      await RemoveUndef(data)
+      assert.equal('d' in data.a.b.c, false)
+    })
+  })
+
+  describe('StartPage', () => {
+    it('should assign _friendlyId to content objects from _startIds', async () => {
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [
+            { _id: 'page1' },
+            { _id: 'page2' }
+          ]
+        }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: {
+            page1: { _id: 'page1' },
+            page2: { _id: 'page2' }
+          }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(importer.contentJson.contentObjects.page1._friendlyId, 'start_page_1')
+      assert.equal(importer.contentJson.contentObjects.page2._friendlyId, 'start_page_2')
+    })
+
+    it('should preserve existing _friendlyId', async () => {
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [{ _id: 'page1' }]
+        }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: {
+            page1: { _id: 'page1', _friendlyId: 'my-custom-id' }
+          }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(importer.contentJson.contentObjects.page1._friendlyId, 'my-custom-id')
+      assert.equal(data._start._startIds[0]._id, 'my-custom-id')
+    })
+
+    it('should log warning for missing content object', async () => {
+      const logFn = mock.fn()
+      const data = {
+        _type: 'course',
+        _start: {
+          _startIds: [{ _id: 'missing' }]
+        }
+      }
+      const importer = {
+        contentJson: { contentObjects: {} },
+        framework: { log: logFn }
+      }
+      await StartPage(data, importer)
+      assert.equal(logFn.mock.calls.length, 1)
+      assert.equal(logFn.mock.calls[0].arguments[0], 'warn')
+    })
+
+    it('should skip non-course types', async () => {
+      const data = { _type: 'config', _start: { _startIds: [{ _id: 'p1' }] } }
+      const importer = { contentJson: { contentObjects: {} } }
+      await StartPage(data, importer)
+    })
+
+    it('should skip when _start is undefined', async () => {
+      const data = { _type: 'course' }
+      await StartPage(data, {})
+    })
+
+    it('should update _startIds[i]._id to match _friendlyId', async () => {
+      const data = {
+        _type: 'course',
+        _start: { _startIds: [{ _id: 'page1' }] }
+      }
+      const importer = {
+        contentJson: {
+          contentObjects: { page1: { _id: 'page1' } }
+        },
+        framework: { log: mock.fn() }
+      }
+      await StartPage(data, importer)
+      assert.equal(data._start._startIds[0]._id, 'start_page_1')
+    })
+  })
+
+  describe('ThemeUndef', () => {
+    it('should set _theme from used plugins when undefined', async () => {
+      const data = { _type: 'config' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' },
+          'adapt-contrib-text': { name: 'adapt-contrib-text', type: 'component' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, 'adapt-contrib-vanilla')
+    })
+
+    it('should not override existing _theme', async () => {
+      const data = { _type: 'config', _theme: 'my-theme' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, 'my-theme')
+    })
+
+    it('should skip non-config types', async () => {
+      const data = { _type: 'course' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-vanilla': { name: 'adapt-contrib-vanilla', type: 'theme' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+
+    it('should set _theme to undefined when no theme plugin found', async () => {
+      const data = { _type: 'config' }
+      const importer = {
+        usedContentPlugins: {
+          'adapt-contrib-text': { name: 'adapt-contrib-text', type: 'component' }
+        }
+      }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+
+    it('should handle empty usedContentPlugins', async () => {
+      const data = { _type: 'config' }
+      const importer = { usedContentPlugins: {} }
+      await ThemeUndef(data, importer)
+      assert.equal(data._theme, undefined)
+    })
+  })
+})