adapt-authoring-integration-tests 0.0.1

package/tests/content.spec.js

@@ -0,0 +1,179 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { getApp, getModule, cleanDb } from '../lib/app.js'
+
+let content
+let authLocal
+let createdBy
+
+describe('Content CRUD operations', () => {
+  before(async () => {
+    await getApp()
+    content = await getModule('content')
+    authLocal = await getModule('auth-local')
+    const user = await authLocal.register({
+      email: 'content-test@example.com',
+      firstName: 'Content',
+      lastName: 'Tester',
+      password: 'Password123!'
+    })
+    createdBy = user._id.toString()
+  })
+
+  after(async () => {
+    await cleanDb(['content', 'users', 'authtokens'])
+  })
+
+  // ---------------------------------------------------------------------------
+  // Course creation
+  // ---------------------------------------------------------------------------
+  describe('Course creation', () => {
+    let course
+
+    it('should insert a course content item', async () => {
+      course = await content.insert(
+        { _type: 'course', title: 'Test Course', createdBy },
+        { validate: false, schemaName: 'course' }
+      )
+      assert.ok(course, 'insert should return a document')
+      assert.ok(course._id, 'course should have an _id')
+      assert.equal(course._type, 'course')
+      assert.equal(course.title, 'Test Course')
+    })
+
+    it('should have set _courseId to its own _id', async () => {
+      assert.ok(course._courseId, 'course should have _courseId')
+      assert.equal(
+        course._courseId.toString(),
+        course._id.toString(),
+        '_courseId should equal _id for a course'
+      )
+    })
+
+    it('should be retrievable via find', async () => {
+      const [found] = await content.find({ _id: course._id })
+      assert.ok(found, 'course should be found in the database')
+      assert.equal(found._type, 'course')
+      assert.equal(found.title, 'Test Course')
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // Content hierarchy
+  // ---------------------------------------------------------------------------
+  describe('Content hierarchy', () => {
+    let course, page, article, block
+
+    before(async () => {
+      course = await content.insert(
+        { _type: 'course', title: 'Hierarchy Course', createdBy },
+        { validate: false, schemaName: 'course' }
+      )
+      page = await content.insert(
+        { _type: 'page', title: 'Test Page', _parentId: course._id.toString(), _courseId: course._id.toString(), createdBy },
+        { validate: false, schemaName: 'contentobject' }
+      )
+      article = await content.insert(
+        { _type: 'article', title: 'Test Article', _parentId: page._id.toString(), _courseId: course._id.toString(), createdBy },
+        { validate: false, schemaName: 'article' }
+      )
+      block = await content.insert(
+        { _type: 'block', title: 'Test Block', _parentId: article._id.toString(), _courseId: course._id.toString(), createdBy },
+        { validate: false, schemaName: 'block' }
+      )
+    })
+
+    it('should create a page with the course as parent', async () => {
+      assert.ok(page._id, 'page should have an _id')
+      assert.equal(page._parentId.toString(), course._id.toString())
+      assert.equal(page._courseId.toString(), course._id.toString())
+    })
+
+    it('should create an article with the page as parent', async () => {
+      assert.ok(article._id, 'article should have an _id')
+      assert.equal(article._parentId.toString(), page._id.toString())
+      assert.equal(article._courseId.toString(), course._id.toString())
+    })
+
+    it('should create a block with the article as parent', async () => {
+      assert.ok(block._id, 'block should have an _id')
+      assert.equal(block._parentId.toString(), article._id.toString())
+      assert.equal(block._courseId.toString(), course._id.toString())
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // Content query by _type
+  // ---------------------------------------------------------------------------
+  describe('Content query', () => {
+    let courseId
+
+    before(async () => {
+      const course = await content.insert(
+        { _type: 'course', title: 'Query Course', createdBy },
+        { validate: false, schemaName: 'course' }
+      )
+      courseId = course._id.toString()
+      await content.insert(
+        { _type: 'page', title: 'Page A', _parentId: courseId, _courseId: courseId, createdBy },
+        { validate: false, schemaName: 'contentobject' }
+      )
+      await content.insert(
+        { _type: 'page', title: 'Page B', _parentId: courseId, _courseId: courseId, createdBy },
+        { validate: false, schemaName: 'contentobject' }
+      )
+      await content.insert(
+        { _type: 'article', title: 'Article A', _parentId: courseId, _courseId: courseId, createdBy },
+        { validate: false, schemaName: 'article' }
+      )
+    })
+
+    it('should find only pages when querying by _type "page"', async () => {
+      const pages = await content.find({ _courseId: courseId, _type: 'page' })
+      assert.equal(pages.length, 2, 'should find exactly 2 pages')
+      assert.ok(pages.every(p => p._type === 'page'), 'all results should be pages')
+    })
+
+    it('should find items using $in operator on _type', async () => {
+      const items = await content.find({ _courseId: courseId, _type: { $in: ['page', 'article'] } })
+      assert.equal(items.length, 3, 'should find 2 pages + 1 article = 3 items')
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // Content update
+  // ---------------------------------------------------------------------------
+  describe('Content update', () => {
+    it('should update a content item title', async () => {
+      const course = await content.insert(
+        { _type: 'course', title: 'Original Title', createdBy },
+        { validate: false, schemaName: 'course' }
+      )
+      const updated = await content.update(
+        { _id: course._id },
+        { title: 'Updated Title' },
+        { validate: false }
+      )
+      assert.equal(updated.title, 'Updated Title')
+      assert.equal(updated._id.toString(), course._id.toString(), '_id should remain the same')
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // Content deletion
+  // ---------------------------------------------------------------------------
+  describe('Content deletion', () => {
+    it('should delete a content item and verify removal', async () => {
+      const course = await content.insert(
+        { _type: 'course', title: 'To Be Deleted', createdBy },
+        { validate: false, schemaName: 'course' }
+      )
+      const courseId = course._id.toString()
+
+      await content.delete({ _id: course._id })
+
+      const results = await content.find({ _id: courseId })
+      assert.equal(results.length, 0, 'deleted course should not be found')
+    })
+  })
+})

package/tests/lib.spec.js

@@ -0,0 +1,43 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { DEFAULT_CLEAN_COLLECTIONS } from '../lib/app.js'
+import { dropTestDb } from '../lib/db.js'
+
+// ---------------------------------------------------------------------------
+// DEFAULT_CLEAN_COLLECTIONS
+// ---------------------------------------------------------------------------
+describe('DEFAULT_CLEAN_COLLECTIONS', () => {
+  it('should include contentplugins to prevent stale plugin records', () => {
+    assert.ok(
+      DEFAULT_CLEAN_COLLECTIONS.includes('contentplugins'),
+      'contentplugins must be in the default clean list — stale records ' +
+      'cause MISSING_SCHEMA errors on subsequent test runs'
+    )
+  })
+
+  it('should include the core content collections', () => {
+    for (const name of ['content', 'assets', 'courseassets', 'tags', 'adaptbuilds']) {
+      assert.ok(
+        DEFAULT_CLEAN_COLLECTIONS.includes(name),
+        `expected "${name}" in DEFAULT_CLEAN_COLLECTIONS`
+      )
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// dropTestDb
+// ---------------------------------------------------------------------------
+describe('dropTestDb()', () => {
+  it('should return false when config directory does not exist', async () => {
+    // Point at a non-existent directory so config import fails
+    const result = await dropTestDb('/tmp/nonexistent-aat-dir')
+    assert.equal(result, false)
+  })
+
+  it('should be a function that accepts a cwd argument', () => {
+    assert.equal(typeof dropTestDb, 'function')
+    assert.equal(dropTestDb.length, 0) // default param, so length is 0
+  })
+})

package/tests/mongodb.spec.js

@@ -0,0 +1,110 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { getApp, getModule } from '../lib/app.js'
+
+const COLLECTION = 'integrationtest'
+
+let mongodb
+
+describe('MongoDB core operations', () => {
+  before(async () => {
+    await getApp()
+    mongodb = await getModule('mongodb')
+  })
+
+  after(async () => {
+    try { await mongodb.getCollection(COLLECTION).drop() } catch {}
+  })
+
+  describe('Insert & Find', () => {
+    let insertedId
+
+    it('should insert a document and return an _id', async () => {
+      const result = await mongodb.insert(COLLECTION, { name: 'Alice', score: 42 })
+      assert.ok(result._id, 'inserted document should have an _id')
+      insertedId = result._id
+    })
+
+    it('should find the document by _id with matching fields', async () => {
+      const [doc] = await mongodb.find(COLLECTION, { _id: insertedId })
+      assert.ok(doc, 'document should be found')
+      assert.equal(doc.name, 'Alice')
+      assert.equal(doc.score, 42)
+    })
+  })
+
+  describe('Insert Multiple', () => {
+    it('should insert multiple documents individually and find them all', async () => {
+      await mongodb.insert(COLLECTION, { name: 'Bob', score: 10 })
+      await mongodb.insert(COLLECTION, { name: 'Carol', score: 20 })
+      await mongodb.insert(COLLECTION, { name: 'Dave', score: 30 })
+
+      const found = await mongodb.find(COLLECTION, { name: { $in: ['Bob', 'Carol', 'Dave'] } })
+      assert.equal(found.length, 3, 'should find all three documents')
+    })
+  })
+
+  describe('Update', () => {
+    let docId
+
+    it('should update a field on an existing document', async () => {
+      const inserted = await mongodb.insert(COLLECTION, { name: 'Eve', score: 50 })
+      docId = inserted._id
+
+      await mongodb.update(COLLECTION, { _id: docId }, { $set: { score: 99 } })
+
+      const [updated] = await mongodb.find(COLLECTION, { _id: docId })
+      assert.equal(updated.score, 99, 'score should be updated to 99')
+      assert.equal(updated.name, 'Eve', 'name should remain unchanged')
+    })
+  })
+
+  describe('Delete', () => {
+    it('should delete a document so it can no longer be found', async () => {
+      const inserted = await mongodb.insert(COLLECTION, { name: 'Frank', score: 0 })
+
+      await mongodb.delete(COLLECTION, { _id: inserted._id })
+
+      const results = await mongodb.find(COLLECTION, { _id: inserted._id })
+      assert.equal(results.length, 0, 'deleted document should not be found')
+    })
+  })
+
+  describe('Query Operators', () => {
+    before(async () => {
+      await mongodb.insert(COLLECTION, { group: 'queries', label: 'low', value: 5 })
+      await mongodb.insert(COLLECTION, { group: 'queries', label: 'mid', value: 15 })
+      await mongodb.insert(COLLECTION, { group: 'queries', label: 'high', value: 25 })
+    })
+
+    it('should support $gt operator', async () => {
+      const results = await mongodb.find(COLLECTION, { group: 'queries', value: { $gt: 10 } })
+      assert.equal(results.length, 2, 'should find two documents with value > 10')
+    })
+
+    it('should support $in operator', async () => {
+      const results = await mongodb.find(COLLECTION, { group: 'queries', label: { $in: ['low', 'high'] } })
+      assert.equal(results.length, 2, 'should find two documents matching $in')
+      const labels = results.map(r => r.label).sort()
+      assert.deepEqual(labels, ['high', 'low'])
+    })
+
+    it('should support $regex operator', async () => {
+      const results = await mongodb.find(COLLECTION, { group: 'queries', label: { $regex: '^h' } })
+      assert.equal(results.length, 1, 'should find one document matching regex')
+      assert.equal(results[0].label, 'high')
+    })
+  })
+
+  describe('Collection Access', () => {
+    it('should return a usable collection object from getCollection()', async () => {
+      const collection = mongodb.getCollection(COLLECTION)
+      assert.ok(collection, 'getCollection should return an object')
+      assert.equal(typeof collection.find, 'function', 'collection should have a find method')
+      assert.equal(typeof collection.insertOne, 'function', 'collection should have an insertOne method')
+
+      const count = await collection.countDocuments({})
+      assert.ok(count > 0, 'collection should contain documents from previous tests')
+    })
+  })
+})

package/tests/roles.spec.js

@@ -0,0 +1,162 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { getApp, getModule } from '../lib/app.js'
+
+let roles
+const createdRoleIds = []
+
+describe('Roles', () => {
+  before(async () => {
+    await getApp()
+    roles = await getModule('roles')
+  })
+
+  after(async () => {
+    for (const id of createdRoleIds) {
+      try {
+        await roles.delete({ _id: id })
+      } catch {
+        // role may already have been removed, that's fine
+      }
+    }
+  })
+
+  // ── Default Roles ───────────────────────────────────────────────────
+
+  describe('Default roles', () => {
+    it('should have created the authuser role on boot', async () => {
+      const [authuser] = await roles.find({ shortName: 'authuser' })
+      assert.ok(authuser, 'authuser role should exist')
+      assert.equal(authuser.shortName, 'authuser')
+    })
+
+    it('should have created the contentcreator role on boot', async () => {
+      const [contentcreator] = await roles.find({ shortName: 'contentcreator' })
+      assert.ok(contentcreator, 'contentcreator role should exist')
+      assert.equal(contentcreator.displayName, 'Content creator')
+    })
+
+    it('should have created the superuser role on boot', async () => {
+      const [superuser] = await roles.find({ shortName: 'superuser' })
+      assert.ok(superuser, 'superuser role should exist')
+      assert.deepEqual(superuser.scopes, ['*:*'])
+    })
+  })
+
+  // ── Scope Inheritance ──────────────────────────────────────────────
+
+  describe('Scope inheritance', () => {
+    let roleA
+    let roleB
+
+    before(async () => {
+      roleA = await roles.insert({
+        shortName: 'testrole-a',
+        displayName: 'Test Role A',
+        scopes: ['read:foo']
+      })
+      createdRoleIds.push(roleA._id)
+
+      roleB = await roles.insert({
+        shortName: 'testrole-b',
+        displayName: 'Test Role B',
+        scopes: ['write:foo'],
+        extends: 'testrole-a'
+      })
+      createdRoleIds.push(roleB._id)
+    })
+
+    it('should return own scopes for a role with no parent', async () => {
+      const scopes = await roles.getScopesForRole(roleA._id)
+      assert.deepEqual(scopes, ['read:foo'])
+    })
+
+    it('should return both own and inherited scopes for a child role', async () => {
+      const scopes = await roles.getScopesForRole(roleB._id)
+      assert.ok(scopes.includes('write:foo'), 'should include own scope write:foo')
+      assert.ok(scopes.includes('read:foo'), 'should include inherited scope read:foo')
+    })
+
+    it('should return child scopes before parent scopes', async () => {
+      const scopes = await roles.getScopesForRole(roleB._id)
+      const writeIdx = scopes.indexOf('write:foo')
+      const readIdx = scopes.indexOf('read:foo')
+      assert.ok(writeIdx < readIdx, 'own scopes should come before inherited scopes')
+    })
+
+    it('should resolve the built-in contentcreator -> authuser chain', async () => {
+      const [contentcreator] = await roles.find({ shortName: 'contentcreator' })
+      const scopes = await roles.getScopesForRole(contentcreator._id)
+      assert.ok(scopes.includes('read:content'), 'should include contentcreator scope')
+      assert.ok(scopes.includes('read:me'), 'should include inherited authuser scope')
+    })
+  })
+
+  // ── Super Role ─────────────────────────────────────────────────────
+
+  describe('Super role', () => {
+    it('should return the ID of the role with *:* scope', async () => {
+      const superRoleId = await roles.getSuperRoleId()
+      assert.ok(superRoleId, 'should return a truthy ID')
+      const [superRole] = await roles.find({ _id: superRoleId })
+      assert.ok(superRole, 'should be a valid role')
+      assert.deepEqual(superRole.scopes, ['*:*'])
+    })
+
+    it('should match the superuser role by shortName', async () => {
+      const superRoleId = await roles.getSuperRoleId()
+      const [superuser] = await roles.find({ shortName: 'superuser' })
+      assert.equal(superRoleId, superuser._id.toString())
+    })
+  })
+
+  // ── Role CRUD ──────────────────────────────────────────────────────
+
+  describe('Role CRUD', () => {
+    let customRole
+
+    it('should create a custom role', async () => {
+      customRole = await roles.insert({
+        shortName: 'testrole-crud',
+        displayName: 'Test CRUD Role',
+        scopes: ['read:test', 'write:test']
+      })
+      createdRoleIds.push(customRole._id)
+      assert.ok(customRole._id, 'inserted role should have an _id')
+      assert.equal(customRole.shortName, 'testrole-crud')
+    })
+
+    it('should find the custom role by shortName', async () => {
+      const [found] = await roles.find({ shortName: 'testrole-crud' })
+      assert.ok(found, 'should find the role')
+      assert.equal(found._id.toString(), customRole._id.toString())
+      assert.deepEqual(found.scopes, ['read:test', 'write:test'])
+    })
+
+    it('should find the custom role by _id', async () => {
+      const [found] = await roles.find({ _id: customRole._id })
+      assert.ok(found, 'should find the role by _id')
+      assert.equal(found.shortName, 'testrole-crud')
+    })
+  })
+
+  // ── Short Name Resolution ─────────────────────────────────────────
+
+  describe('Short name resolution', () => {
+    it('should resolve authuser shortName to its database ID', async () => {
+      const [authuser] = await roles.find({ shortName: 'authuser' })
+      const ids = await roles.shortNamesToIds(['authuser'])
+      assert.equal(ids.length, 1)
+      assert.equal(ids[0], authuser._id.toString())
+    })
+
+    it('should resolve multiple shortNames in a single call', async () => {
+      const [authuser] = await roles.find({ shortName: 'authuser' })
+      const [superuser] = await roles.find({ shortName: 'superuser' })
+      const ids = await roles.shortNamesToIds(['authuser', 'superuser'])
+      assert.equal(ids.length, 2)
+      assert.equal(ids[0], authuser._id.toString())
+      assert.equal(ids[1], superuser._id.toString())
+    })
+  })
+})

package/tests/users.spec.js

@@ -0,0 +1,113 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { getApp, getModule, cleanDb } from '../lib/app.js'
+
+let users
+let authLocal
+
+describe('Users module', () => {
+  before(async () => {
+    await getApp()
+    users = await getModule('users')
+    authLocal = await getModule('auth-local')
+  })
+
+  after(async () => {
+    await cleanDb(['users', 'authtokens', 'passwordresets'])
+  })
+
+  describe('User creation', () => {
+    it('should create a user via authLocal.register()', async () => {
+      const user = await authLocal.register({
+        email: 'create-test@example.com',
+        firstName: 'Create',
+        lastName: 'Test',
+        password: 'Password123!'
+      })
+      assert.ok(user, 'register should return a user object')
+      assert.ok(user._id, 'user should have an _id')
+    })
+
+    it('should be retrievable via users.find()', async () => {
+      const results = await users.find({ email: 'create-test@example.com' })
+      assert.equal(results.length, 1, 'should find exactly one user')
+      assert.equal(results[0].firstName, 'Create')
+      assert.equal(results[0].lastName, 'Test')
+    })
+  })
+
+  describe('Email case insensitivity', () => {
+    it('should create a user with mixed case email', async () => {
+      const user = await authLocal.register({
+        email: 'MixedCase@Example.COM',
+        firstName: 'Mixed',
+        lastName: 'Case',
+        password: 'Password123!'
+      })
+      assert.ok(user._id, 'user should be created')
+    })
+
+    it('should store the email as lowercase', async () => {
+      const results = await users.find({ email: 'mixedcase@example.com' })
+      assert.equal(results.length, 1, 'should find the user with lowercase email')
+      assert.equal(results[0].email, 'mixedcase@example.com', 'stored email should be lowercase')
+    })
+
+    it('should find the user when querying with different case', async () => {
+      const results = await users.find({ email: 'MIXEDCASE@EXAMPLE.COM' })
+      assert.equal(results.length, 1, 'should find the user regardless of query case')
+      assert.equal(results[0].firstName, 'Mixed')
+    })
+  })
+
+  describe('Duplicate email', () => {
+    it('should reject a second user with the same email', async () => {
+      await assert.rejects(
+        () => authLocal.register({
+          email: 'create-test@example.com',
+          firstName: 'Duplicate',
+          lastName: 'User',
+          password: 'Password123!'
+        }),
+        (err) => {
+          const isDuplError = err.code === 'DUPL_USER' ||
+            err.code === 'MONGO_DUPL_INDEX' ||
+            /dupl/i.test(err.message) ||
+            /E11000/i.test(err.message)
+          assert.ok(isDuplError, `expected a duplicate error, got: ${err.code || err.message}`)
+          return true
+        }
+      )
+    })
+  })
+
+  describe('User update', () => {
+    it('should update a user firstName', async () => {
+      const [user] = await users.find({ email: 'create-test@example.com' })
+      await users.update({ _id: user._id }, { firstName: 'Updated' })
+      const [updated] = await users.find({ _id: user._id })
+      assert.equal(updated.firstName, 'Updated', 'firstName should be updated')
+    })
+  })
+
+  describe('User deletion', () => {
+    const deleteEmail = 'delete-me@example.com'
+
+    it('should create a user to be deleted', async () => {
+      const user = await authLocal.register({
+        email: deleteEmail,
+        firstName: 'Delete',
+        lastName: 'Me',
+        password: 'Password123!'
+      })
+      assert.ok(user._id, 'user should be created')
+    })
+
+    it('should delete the user', async () => {
+      const [user] = await users.find({ email: deleteEmail })
+      await users.delete({ _id: user._id })
+      const results = await users.find({ email: deleteEmail })
+      assert.equal(results.length, 0, 'user should no longer exist after deletion')
+    })
+  })
+})