adapt-authoring-content 2.1.8 → 3.0.0

package/tests/ContentTree.spec.js

@@ -0,0 +1,230 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import ContentTree from '../lib/ContentTree.js'
+
+describe('ContentTree', () => {
+  const makeId = (n) => ({ toString: () => `id${n}` })
+
+  const items = [
+    { _id: makeId(1), _type: 'course', _courseId: 'c1' },
+    { _id: makeId(2), _type: 'config', _courseId: 'c1' },
+    { _id: makeId(3), _type: 'page', _courseId: 'c1', _parentId: makeId(1) },
+    { _id: makeId(4), _type: 'menu', _courseId: 'c1', _parentId: makeId(1) },
+    { _id: makeId(5), _type: 'article', _courseId: 'c1', _parentId: makeId(3) },
+    { _id: makeId(6), _type: 'article', _courseId: 'c1', _parentId: makeId(3) },
+    { _id: makeId(7), _type: 'block', _courseId: 'c1', _parentId: makeId(5) },
+    { _id: makeId(8), _type: 'block', _courseId: 'c1', _parentId: makeId(5) },
+    { _id: makeId(9), _type: 'component', _courseId: 'c1', _parentId: makeId(7), _component: 'adapt-contrib-text' },
+    { _id: makeId(10), _type: 'component', _courseId: 'c1', _parentId: makeId(8), _component: 'adapt-contrib-media' }
+  ]
+
+  describe('constructor', () => {
+    it('should index all items by id', () => {
+      const tree = new ContentTree(items)
+      assert.equal(tree.byId.size, 10)
+      assert.strictEqual(tree.byId.get('id1'), items[0])
+    })
+
+    it('should set course and config references', () => {
+      const tree = new ContentTree(items)
+      assert.strictEqual(tree.course, items[0])
+      assert.strictEqual(tree.config, items[1])
+    })
+
+    it('should handle items with no course or config', () => {
+      const tree = new ContentTree([
+        { _id: makeId(1), _type: 'page', _parentId: makeId(99) }
+      ])
+      assert.equal(tree.course, null)
+      assert.equal(tree.config, null)
+    })
+
+    it('should store items array', () => {
+      const tree = new ContentTree(items)
+      assert.strictEqual(tree.items, items)
+    })
+
+    it('should handle empty items array', () => {
+      const tree = new ContentTree([])
+      assert.equal(tree.byId.size, 0)
+      assert.equal(tree.course, null)
+      assert.equal(tree.config, null)
+    })
+  })
+
+  describe('getById', () => {
+    it('should return item by string id', () => {
+      const tree = new ContentTree(items)
+      assert.strictEqual(tree.getById('id3'), items[2])
+    })
+
+    it('should return item by object with toString', () => {
+      const tree = new ContentTree(items)
+      assert.strictEqual(tree.getById(makeId(3)), items[2])
+    })
+
+    it('should return undefined for non-existent id', () => {
+      const tree = new ContentTree(items)
+      assert.equal(tree.getById('missing'), undefined)
+    })
+  })
+
+  describe('getChildren', () => {
+    it('should return children of a parent', () => {
+      const tree = new ContentTree(items)
+      const children = tree.getChildren('id1')
+      assert.equal(children.length, 2)
+      assert.ok(children.some(c => c._type === 'page'))
+      assert.ok(children.some(c => c._type === 'menu'))
+    })
+
+    it('should return empty array for leaf nodes', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getChildren('id9'), [])
+    })
+
+    it('should return empty array for non-existent parent', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getChildren('missing'), [])
+    })
+
+    it('should accept object with toString', () => {
+      const tree = new ContentTree(items)
+      const children = tree.getChildren(makeId(1))
+      assert.equal(children.length, 2)
+    })
+  })
+
+  describe('getByType', () => {
+    it('should return all items of a given type', () => {
+      const tree = new ContentTree(items)
+      assert.equal(tree.getByType('article').length, 2)
+      assert.equal(tree.getByType('component').length, 2)
+      assert.equal(tree.getByType('course').length, 1)
+    })
+
+    it('should return empty array for non-existent type', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getByType('unknown'), [])
+    })
+  })
+
+  describe('getDescendants', () => {
+    it('should return all descendants of the course root', () => {
+      const tree = new ContentTree(items)
+      const desc = tree.getDescendants('id1')
+      // page, menu, 2 articles, 2 blocks, 2 components = 8 (config excluded since it has no _parentId chain to course)
+      assert.equal(desc.length, 8)
+    })
+
+    it('should return all descendants of a page', () => {
+      const tree = new ContentTree(items)
+      const desc = tree.getDescendants('id3')
+      // 2 articles, 2 blocks, 2 components = 6
+      assert.equal(desc.length, 6)
+    })
+
+    it('should return all descendants of an article', () => {
+      const tree = new ContentTree(items)
+      const desc = tree.getDescendants('id5')
+      // 2 blocks, 2 components = 4
+      assert.equal(desc.length, 4)
+    })
+
+    it('should return empty array for leaf nodes', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getDescendants('id9'), [])
+    })
+
+    it('should return empty array for non-existent id', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getDescendants('missing'), [])
+    })
+
+    it('should not include the root item itself', () => {
+      const tree = new ContentTree(items)
+      const desc = tree.getDescendants('id3')
+      assert.ok(!desc.some(d => d._id.toString() === 'id3'))
+    })
+  })
+
+  describe('getAncestors', () => {
+    it('should return ancestors from leaf to root', () => {
+      const tree = new ContentTree(items)
+      const ancestors = tree.getAncestors('id9')
+      // block -> article -> page -> course
+      assert.equal(ancestors.length, 4)
+      assert.equal(ancestors[0]._type, 'block')
+      assert.equal(ancestors[1]._type, 'article')
+      assert.equal(ancestors[2]._type, 'page')
+      assert.equal(ancestors[3]._type, 'course')
+    })
+
+    it('should return empty array for root items', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getAncestors('id1'), [])
+    })
+
+    it('should return empty array for config (no _parentId)', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getAncestors('id2'), [])
+    })
+
+    it('should return empty array for non-existent id', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getAncestors('missing'), [])
+    })
+  })
+
+  describe('getSiblings', () => {
+    it('should return siblings excluding the item itself', () => {
+      const tree = new ContentTree(items)
+      const siblings = tree.getSiblings('id5')
+      assert.equal(siblings.length, 1)
+      assert.equal(siblings[0]._id.toString(), 'id6')
+    })
+
+    it('should return empty array for items with no _parentId', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getSiblings('id1'), [])
+    })
+
+    it('should return empty array for only children', () => {
+      const tree = new ContentTree(items)
+      const siblings = tree.getSiblings('id9')
+      assert.equal(siblings.length, 0)
+    })
+
+    it('should return empty array for non-existent id', () => {
+      const tree = new ContentTree(items)
+      assert.deepEqual(tree.getSiblings('missing'), [])
+    })
+  })
+
+  describe('getComponentNames', () => {
+    it('should return unique component names', () => {
+      const tree = new ContentTree(items)
+      const names = tree.getComponentNames()
+      assert.equal(names.length, 2)
+      assert.ok(names.includes('adapt-contrib-text'))
+      assert.ok(names.includes('adapt-contrib-media'))
+    })
+
+    it('should deduplicate component names', () => {
+      const dupeItems = [
+        { _id: makeId(1), _type: 'component', _component: 'adapt-contrib-text' },
+        { _id: makeId(2), _type: 'component', _component: 'adapt-contrib-text' },
+        { _id: makeId(3), _type: 'component', _component: 'adapt-contrib-media' }
+      ]
+      const tree = new ContentTree(dupeItems)
+      assert.equal(tree.getComponentNames().length, 2)
+    })
+
+    it('should return empty array when no components exist', () => {
+      const tree = new ContentTree([
+        { _id: makeId(1), _type: 'course' }
+      ])
+      assert.deepEqual(tree.getComponentNames(), [])
+    })
+  })
+})

package/tests/_ht.js

@@ -0,0 +1,116 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import ContentModule from '../lib/ContentModule.js'
+
+const COURSE_ID = '507f1f77bcf86cd799439011'
+
+function createMockCollection (overrides = {}) {
+  return {
+    findOne: mock.fn(async () => null),
+    updateOne: mock.fn(async () => {}),
+    findOneAndUpdate: mock.fn(async () => ({ seq: 1 })),
+    find: mock.fn(() => ({ toArray: mock.fn(async () => []) })),
+    deleteMany: mock.fn(async () => {}),
+    ...overrides
+  }
+}
+
+function createMockMongodb (collectionOverrides) {
+  const col = createMockCollection(collectionOverrides)
+  return { getCollection: mock.fn(() => col), collection: col }
+}
+
+function createInstance (overrides = {}) {
+  return {
+    schemaName: 'content',
+    collectionName: 'content',
+    counterCollectionName: 'contentcounters',
+    idInterval: 5,
+    contentplugin: { findOne: mock.fn(async () => null) },
+    jsonschema: { extendSchema: mock.fn() },
+    authored: { schemaName: 'authored' },
+    tags: { schemaExtensionName: 'tags' },
+    mongodb: createMockMongodb(),
+    find: mock.fn(async () => []),
+    findOne: mock.fn(async () => null),
+    ...overrides
+  }
+}
+
+describe('ContentModule', () => {
+  describe('handleTree', () => {
+    it('should return 304 when content has not been modified', async () => {
+      const lastModified = new Date('2025-01-01T00:00:00Z')
+      const inst = createInstance({
+        findOne: mock.fn(async () => ({ updatedAt: lastModified }))
+      })
+      let statusCode
+      let ended = false
+      const req = {
+        apiData: { query: { _courseId: COURSE_ID } },
+        headers: { 'if-modified-since': new Date('2025-01-02T00:00:00Z').toUTCString() }
+      }
+      const res = {
+        status: mock.fn(function (code) { statusCode = code; return this }),
+        end: mock.fn(() => { ended = true })
+      }
+      const next = mock.fn()
+      await ContentModule.prototype.handleTree.call(inst, req, res, next)
+      assert.equal(statusCode, 304)
+      assert.equal(ended, true)
+      assert.equal(next.mock.callCount(), 0)
+    })
+
+    it('should return items with _children when content has been modified', async () => {
+      const lastModified = new Date('2025-01-15T00:00:00Z')
+      const items = [
+        { _id: COURSE_ID, _type: 'course', _courseId: COURSE_ID },
+        { _id: 'page1', _type: 'page', _parentId: COURSE_ID, _courseId: COURSE_ID },
+        { _id: 'art1', _type: 'article', _parentId: 'page1', _courseId: COURSE_ID }
+      ]
+      const inst = createInstance({
+        findOne: mock.fn(async () => ({ updatedAt: lastModified })),
+        find: mock.fn(async () => items)
+      })
+      const req = {
+        apiData: { query: { _courseId: COURSE_ID } },
+        headers: {}
+      }
+      let responseData
+      let lastModifiedHeader
+      const res = {
+        set: mock.fn((key, val) => { if (key === 'Last-Modified') lastModifiedHeader = val }),
+        json: mock.fn((data) => { responseData = data })
+      }
+      const next = mock.fn()
+      await ContentModule.prototype.handleTree.call(inst, req, res, next)
+
+      assert.equal(next.mock.callCount(), 0)
+      assert.equal(responseData.length, 3)
+      // course should have page1 as child
+      const course = responseData.find(i => i._id === COURSE_ID)
+      assert.deepEqual(course._children, ['page1'])
+      // page should have art1 as child
+      const page = responseData.find(i => i._id === 'page1')
+      assert.deepEqual(page._children, ['art1'])
+      // article should have no children
+      const art = responseData.find(i => i._id === 'art1')
+      assert.deepEqual(art._children, [])
+      // Last-Modified header should be set
+      assert.equal(lastModifiedHeader, lastModified.toUTCString())
+    })
+
+    it('should call next on error', async () => {
+      const inst = createInstance({
+        findOne: mock.fn(async () => { throw new Error('db error') })
+      })
+      const req = { apiData: { query: { _courseId: COURSE_ID } }, headers: {} }
+      const res = {}
+      const next = mock.fn()
+      await ContentModule.prototype.handleTree.call(inst, req, res, next)
+      assert.equal(next.mock.callCount(), 1)
+      assert.equal(next.mock.calls[0].arguments[0].message, 'db error')
+    })
+  })
+})

package/tests/utils-computeSortOrderOps.spec.js

@@ -0,0 +1,94 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import computeSortOrderOps from '../lib/utils/computeSortOrderOps.js'
+
+describe('computeSortOrderOps', () => {
+  it('returns empty array when all siblings already have correct _sortOrder', () => {
+    const siblings = [
+      { _id: 'a', _sortOrder: 1 },
+      { _id: 'b', _sortOrder: 2 }
+    ]
+    assert.deepEqual(computeSortOrderOps(siblings), [])
+  })
+
+  it('returns ops to fix incorrect _sortOrder values', () => {
+    const siblings = [
+      { _id: 'a', _sortOrder: 3 },
+      { _id: 'b', _sortOrder: 5 }
+    ]
+    const ops = computeSortOrderOps(siblings)
+    assert.equal(ops.length, 2)
+    assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'a' }, update: { $set: { _sortOrder: 1 } } } })
+    assert.deepEqual(ops[1], { updateOne: { filter: { _id: 'b' }, update: { $set: { _sortOrder: 2 } } } })
+  })
+
+  it('returns empty array for empty siblings', () => {
+    assert.deepEqual(computeSortOrderOps([]), [])
+  })
+
+  describe('with item insertion', () => {
+    it('appends item to end when _sortOrder is null', () => {
+      const siblings = [
+        { _id: 'a', _sortOrder: 1 }
+      ]
+      const item = { _id: 'new', _sortOrder: null }
+      const ops = computeSortOrderOps(siblings, item)
+      assert.equal(ops.length, 1)
+      assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'new' }, update: { $set: { _sortOrder: 2 } } } })
+    })
+
+    it('appends item to end when _sortOrder is undefined', () => {
+      const siblings = [
+        { _id: 'a', _sortOrder: 1 }
+      ]
+      const item = { _id: 'new' }
+      const ops = computeSortOrderOps(siblings, item)
+      assert.equal(ops.length, 1)
+      assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'new' }, update: { $set: { _sortOrder: 2 } } } })
+    })
+
+    it('inserts item at position based on _sortOrder', () => {
+      const siblings = [
+        { _id: 'a', _sortOrder: 1 },
+        { _id: 'b', _sortOrder: 2 }
+      ]
+      const item = { _id: 'new', _sortOrder: 2 }
+      const ops = computeSortOrderOps(siblings, item)
+      // item spliced at index 1 (_sortOrder - 1 = 1)
+      // result: [a, new, b] -> sortOrders [1, 2, 3]
+      // a already has _sortOrder 1, new already has 2, only b needs updating 2→3
+      assert.equal(ops.length, 1)
+      assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'b' }, update: { $set: { _sortOrder: 3 } } } })
+    })
+
+    it('appends to end when _sortOrder is 0', () => {
+      const siblings = [
+        { _id: 'a', _sortOrder: 1 },
+        { _id: 'b', _sortOrder: 2 }
+      ]
+      const item = { _id: 'new', _sortOrder: 0 }
+      const ops = computeSortOrderOps(siblings, item)
+      // _sortOrder - 1 = -1, which is not > -1, so appends to end
+      assert.equal(ops.length, 1)
+      assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'new' }, update: { $set: { _sortOrder: 3 } } } })
+    })
+
+    it('inserts into empty siblings list', () => {
+      const item = { _id: 'new', _sortOrder: null }
+      const ops = computeSortOrderOps([], item)
+      assert.equal(ops.length, 1)
+      assert.deepEqual(ops[0], { updateOne: { filter: { _id: 'new' }, update: { $set: { _sortOrder: 1 } } } })
+    })
+
+    it('only returns ops for items that need updating', () => {
+      const siblings = [
+        { _id: 'a', _sortOrder: 1 },
+        { _id: 'b', _sortOrder: 3 }
+      ]
+      const item = { _id: 'new', _sortOrder: 2 }
+      const ops = computeSortOrderOps(siblings, item)
+      // result: [a, new, b] -> [1, 2, 3] — a=1 ok, new=2 ok, b=3 ok — no ops needed
+      assert.equal(ops.length, 0)
+    })
+  })
+})

package/tests/utils-contentTypeToSchemaName.spec.js

@@ -0,0 +1,21 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import contentTypeToSchemaName from '../lib/utils/contentTypeToSchemaName.js'
+
+describe('contentTypeToSchemaName', () => {
+  const cases = [
+    { _type: 'page', expected: 'contentobject' },
+    { _type: 'menu', expected: 'contentobject' },
+    { _type: 'article', expected: 'article' },
+    { _type: 'block', expected: 'block' },
+    { _type: 'component', expected: 'component' },
+    { _type: 'course', expected: 'course' },
+    { _type: 'config', expected: 'config' }
+  ]
+
+  for (const { _type, expected } of cases) {
+    it(`maps "${_type}" to "${expected}"`, () => {
+      assert.equal(contentTypeToSchemaName(_type), expected)
+    })
+  }
+})

package/tests/utils-extractAssetIds.spec.js

@@ -0,0 +1,118 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { extractAssetIds } from '../lib/utils/extractAssetIds.js'
+
+/**
+ * Creates a minimal schema-like object with a walk method that
+ * mirrors Schema.walk behaviour for the given properties
+ */
+function mockSchema (properties) {
+  return {
+    walk (data, predicate, schema, parentPath = '') {
+      schema = schema ?? properties
+      const matches = []
+      for (const [key, val] of Object.entries(schema)) {
+        if (data[key] === undefined) continue
+        const currentPath = parentPath ? `${parentPath}/${key}` : key
+        if (val.properties) {
+          matches.push(...this.walk(data[key], predicate, val.properties, currentPath))
+        } else if (val?.items?.properties) {
+          data[key].forEach((item, i) => {
+            matches.push(...this.walk(item, predicate, val.items.properties, `${currentPath}/${i}`))
+          })
+        } else if (predicate(val)) {
+          matches.push({ path: currentPath, key, data, value: data[key] })
+        }
+      }
+      return matches
+    }
+  }
+}
+
+describe('extractAssetIds()', () => {
+  it('should return empty array when no asset fields exist', () => {
+    const schema = mockSchema({ title: { type: 'string' } })
+    assert.deepEqual(extractAssetIds(schema, { title: 'test' }), [])
+  })
+
+  it('should extract asset ID from _backboneForms Asset string type', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, { image: 'abc123' }), ['abc123'])
+  })
+
+  it('should extract asset ID from _backboneForms.type Asset', () => {
+    const schema = mockSchema({ image: { _backboneForms: { type: 'Asset' } } })
+    assert.deepEqual(extractAssetIds(schema, { image: 'abc123' }), ['abc123'])
+  })
+
+  it('should skip keys not present in data', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, {}), [])
+  })
+
+  it('should skip falsy asset values', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, { image: '' }), [])
+  })
+
+  it('should skip HTTP URLs', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, { image: 'http://example.com/image.png' }), [])
+  })
+
+  it('should skip HTTPS URLs', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, { image: 'https://example.com/image.png' }), [])
+  })
+
+  it('should recurse into nested schema properties', () => {
+    const schema = mockSchema({
+      _graphic: {
+        properties: {
+          src: { _backboneForms: 'Asset' }
+        }
+      }
+    })
+    assert.deepEqual(extractAssetIds(schema, { _graphic: { src: 'img123' } }), ['img123'])
+  })
+
+  it('should recurse into array items with properties', () => {
+    const schema = mockSchema({
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    })
+    assert.deepEqual(extractAssetIds(schema, { _items: [{ src: 'a1' }, { src: 'a2' }] }), ['a1', 'a2'])
+  })
+
+  it('should deduplicate asset IDs', () => {
+    const schema = mockSchema({
+      _items: {
+        items: {
+          properties: {
+            src: { _backboneForms: 'Asset' }
+          }
+        }
+      }
+    })
+    assert.deepEqual(extractAssetIds(schema, { _items: [{ src: 'same' }, { src: 'same' }] }), ['same'])
+  })
+
+  it('should handle toString on non-string asset values', () => {
+    const schema = mockSchema({ image: { _backboneForms: 'Asset' } })
+    assert.deepEqual(extractAssetIds(schema, { image: { toString: () => 'obj123' } }), ['obj123'])
+  })
+
+  it('should handle multiple asset fields at the same level', () => {
+    const schema = mockSchema({
+      image1: { _backboneForms: 'Asset' },
+      image2: { _backboneForms: { type: 'Asset' } },
+      title: { type: 'string' }
+    })
+    assert.deepEqual(extractAssetIds(schema, { image1: 'a1', image2: 'a2', title: 'test' }), ['a1', 'a2'])
+  })
+})

package/tests/utils-formatFriendlyId.spec.js

@@ -0,0 +1,40 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import formatFriendlyId from '../lib/utils/formatFriendlyId.js'
+
+describe('formatFriendlyId', () => {
+  describe('course type', () => {
+    it('formats without language', () => {
+      assert.equal(formatFriendlyId('course', 1), 'course-1')
+    })
+
+    it('formats with language', () => {
+      assert.equal(formatFriendlyId('course', 3, 'en'), 'course-3-en')
+    })
+
+    it('omits language suffix when _language is empty string', () => {
+      assert.equal(formatFriendlyId('course', 2, ''), 'course-2')
+    })
+  })
+
+  describe('config type', () => {
+    it('always returns "config"', () => {
+      assert.equal(formatFriendlyId('config'), 'config')
+    })
+  })
+
+  describe('other types', () => {
+    const cases = [
+      { _type: 'page', count: 1, expected: 'p-1' },
+      { _type: 'article', count: 2, expected: 'a-2' },
+      { _type: 'block', count: 3, expected: 'b-3' },
+      { _type: 'component', count: 4, expected: 'c-4' }
+    ]
+
+    for (const { _type, count, expected } of cases) {
+      it(`formats ${_type} with count ${count} as "${expected}"`, () => {
+        assert.equal(formatFriendlyId(_type, count), expected)
+      })
+    }
+  })
+})

package/tests/utils-parseMaxSeq.spec.js

@@ -0,0 +1,49 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import parseMaxSeq from '../lib/utils/parseMaxSeq.js'
+
+describe('parseMaxSeq', () => {
+  it('returns 0 for empty docs array', () => {
+    assert.equal(parseMaxSeq([]), 0)
+  })
+
+  it('returns max number for course type', () => {
+    const docs = [
+      { _friendlyId: 'course-3' },
+      { _friendlyId: 'course-7' },
+      { _friendlyId: 'course-2' }
+    ]
+    assert.equal(parseMaxSeq(docs), 7)
+  })
+
+  it('returns raw max number for non-course types', () => {
+    const docs = [
+      { _friendlyId: 'b-10' },
+      { _friendlyId: 'b-25' },
+      { _friendlyId: 'b-5' }
+    ]
+    assert.equal(parseMaxSeq(docs), 25)
+  })
+
+  it('returns raw number without flooring', () => {
+    const docs = [{ _friendlyId: 'a-13' }]
+    assert.equal(parseMaxSeq(docs), 13)
+  })
+
+  it('skips docs with no _friendlyId', () => {
+    const docs = [
+      { _friendlyId: 'p-10' },
+      {},
+      { _friendlyId: undefined }
+    ]
+    assert.equal(parseMaxSeq(docs), 10)
+  })
+
+  it('skips docs with no numeric portion', () => {
+    const docs = [
+      { _friendlyId: 'config' },
+      { _friendlyId: 'p-15' }
+    ]
+    assert.equal(parseMaxSeq(docs), 15)
+  })
+})