adapt-authoring-integration-tests 0.0.1

package/.github/workflows/releases.yml

@@ -0,0 +1,32 @@
+name: Release
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # to be able to publish a GitHub release
+      issues: write # to be able to comment on released issues
+      pull-requests: write # to be able to comment on released pull requests
+      id-token: write # to enable use of OIDC for trusted publishing and npm provenance
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 'lts/*'
+      - name: Update npm
+        run: npm install -g npm@latest
+      - name: Install dependencies
+        run: npm install
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npx semantic-release

package/.github/workflows/standardjs.yml

@@ -0,0 +1,12 @@
+name: Lint
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+      - run: npm install
+      - run: npx standard

package/README.md

@@ -0,0 +1,73 @@
+# Adapt Authoring Integration Tests
+
+Integration test suite for the Adapt authoring tool. Tests the full application with a real database, covering import, build, and export workflows.
+
+## Prerequisites
+
+- Node.js 24+
+- MongoDB 8.0+
+- The adapt-authoring app with dependencies installed
+
+## Setup
+
+Create a fixtures directory with a `manifest.json` and your test fixture files:
+
+```bash
+mkdir /path/to/fixtures
+echo '{ "course-export": "course-export.zip" }' > /path/to/fixtures/manifest.json
+cp /path/to/your-course-export.zip /path/to/fixtures/course-export.zip
+```
+
+See `fixtures/manifest.example.json` for the expected format.
+
+## Running tests
+
+From the **adapt-authoring app directory**:
+
+```bash
+# Set required environment variables
+export ADAPT_AUTHORING_AUTH__tokenSecret='testsecret'
+export ADAPT_AUTHORING_MONGODB__connectionUri='mongodb://0.0.0.0/adapt-authoring-test'
+export ADAPT_AUTHORING_SERVER__host='localhost'
+export ADAPT_AUTHORING_SERVER__port='5678'
+export ADAPT_AUTHORING_SERVER__url='http://localhost:5678'
+export ADAPT_AUTHORING_SESSIONS__secret='testsessionssecret'
+
+# Run all integration tests
+FIXTURES_DIR=/path/to/fixtures npx at-integration-test
+
+# Run only import tests
+FIXTURES_DIR=/path/to/fixtures npx at-integration-test --import-only
+
+# Run only build tests
+FIXTURES_DIR=/path/to/fixtures npx at-integration-test --build-only
+```
+
+## Custom tests (e.g. client testing)
+
+Point `CUSTOM_DIR` to a directory containing custom `fixtures/` and `tests/`:
+
+```
+my-client-tests/
+  fixtures/
+    manifest.json
+    client-course.zip
+  tests/
+    client-specific.spec.js
+```
+
+```bash
+CUSTOM_DIR=/path/to/my-client-tests npx at-integration-test
+```
+
+Custom fixtures are merged with the standard fixtures (custom takes priority on key collisions). Custom tests are run alongside the standard tests.
+
+## CI
+
+The GitHub Actions workflow runs weekly and can be triggered manually via `workflow_dispatch`. It:
+
+1. Checks out both this repo and the main adapt-authoring repo
+2. Downloads test fixtures from a separate repository
+3. Starts MongoDB via `supercharge/mongodb-github-action`
+4. Installs app dependencies
+5. Runs all integration tests

package/adapt-authoring.json

@@ -0,0 +1,6 @@
+{
+  "module": false,
+  "documentation": {
+    "enable": true
+  }
+}

package/bin/run.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+/**
+ * Integration test runner.
+ *
+ * Must be run from the adapt-authoring app directory (where node_modules are installed).
+ *
+ * Usage:
+ *   npx at-integration-test                    # run all tests
+ *   npx at-integration-test auth               # run auth.spec.js
+ *   npx at-integration-test mongodb content    # run mongodb.spec.js and content.spec.js
+ *   CUSTOM_DIR=/path/to/custom npx at-integration-test
+ *
+ * Environment variables:
+ *   CUSTOM_DIR - Path to a directory containing additional fixtures/ and/or tests/
+ *                Custom fixtures override built-in fixtures when keys collide.
+ */
+
+import { execSync } from 'child_process'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dropTestDb } from '../lib/db.js'
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const testsDir = path.join(ROOT, 'tests')
+const customDir = process.env.CUSTOM_DIR
+  ? path.isAbsolute(process.env.CUSTOM_DIR) ? process.env.CUSTOM_DIR : path.resolve(process.env.CUSTOM_DIR)
+  : undefined
+
+// Collect test file paths
+const testFiles = []
+const args = process.argv.slice(2)
+
+if (args.length > 0) {
+  for (const name of args) {
+    const specFile = path.join(testsDir, `${name}.spec.js`)
+    if (!fs.existsSync(specFile)) {
+      console.error(`Test not found: ${name} (expected ${specFile})`)
+      process.exit(1)
+    }
+    testFiles.push(specFile)
+  }
+} else {
+  const files = fs.readdirSync(testsDir).filter(f => f.endsWith('.spec.js')).sort()
+  testFiles.push(...files.map(f => path.join(testsDir, f)))
+}
+
+// Add custom tests if CUSTOM_DIR is set
+const customTestFiles = []
+if (customDir) {
+  const customTestsDir = path.join(customDir, 'tests')
+  if (fs.existsSync(customTestsDir)) {
+    const customFiles = fs.readdirSync(customTestsDir).filter(f => f.endsWith('.spec.js')).sort()
+    customTestFiles.push(...customFiles.map(f => path.join(customTestsDir, f)))
+    testFiles.push(...customTestFiles)
+  }
+}
+
+// Drop the test database to ensure a clean state before the app boots.
+// Stale records (e.g. contentplugins from a previous run) can cause
+// initPlugins to look for plugin files that no longer exist.
+await dropTestDb()
+
+// Generate a single entry file that imports all specs so the app boots once
+const imports = testFiles.map(f => `import '${f}'`).join('\n')
+const entryFile = path.join(os.tmpdir(), `aat-test-entry-${Date.now()}.js`)
+fs.writeFileSync(entryFile, imports + '\n')
+
+const cmd = `node --test --test-force-exit '${entryFile}'`
+
+console.log(`Tests:\n${testFiles.map(f => `  ${path.basename(f)}`).join('\n')}`)
+if (customTestFiles.length) {
+  console.log(`Custom scripts:\n${customTestFiles.map(f => `  ${path.basename(f)}`).join('\n')}`)
+}
+console.log()
+
+try {
+  execSync(cmd, { stdio: 'inherit', env: process.env })
+} finally {
+  try { fs.unlinkSync(entryFile) } catch {}
+}

package/fixtures/manifest.example.json

@@ -0,0 +1,3 @@
+{
+  "course-export": "course-export.zip"
+}

package/lib/app.js

@@ -0,0 +1,49 @@
+import { App } from 'adapt-authoring-core'
+
+let app
+
+/**
+ * Boots the Adapt authoring app and returns the App instance.
+ * Caches the instance so subsequent calls return the same app.
+ * @returns {Promise<App>}
+ */
+export async function getApp () {
+  if (app) return app
+  process.env.NODE_ENV = process.env.NODE_ENV || 'testing'
+  app = await App.instance.onReady()
+  return app
+}
+
+/**
+ * Waits for a named module to be ready and returns it.
+ * @param {string} name - Module name (e.g. 'adaptframework', 'content')
+ * @returns {Promise<Object>}
+ */
+export async function getModule (name) {
+  const a = await getApp()
+  return a.waitForModule(name)
+}
+
+/**
+ * Default collections cleaned between test runs.
+ * Must include 'contentplugins' to avoid stale plugin records causing
+ * MISSING_SCHEMA errors on subsequent runs.
+ * @type {string[]}
+ */
+export const DEFAULT_CLEAN_COLLECTIONS = ['content', 'assets', 'courseassets', 'tags', 'adaptbuilds', 'contentplugins']
+
+/**
+ * Cleans up test data from the database.
+ * Call this in after() hooks to leave the DB clean.
+ * @param {string[]} collections - Collection names to clear
+ */
+export async function cleanDb (collections = DEFAULT_CLEAN_COLLECTIONS) {
+  const mongodb = await getModule('mongodb')
+  for (const name of collections) {
+    try {
+      await mongodb.getCollection(name).deleteMany({})
+    } catch {
+      // collection may not exist yet, that's fine
+    }
+  }
+}

package/lib/db.js

@@ -0,0 +1,28 @@
+import path from 'path'
+
+/**
+ * Drops the test database to ensure a clean state before the app boots.
+ *
+ * Stale records (e.g. contentplugins from a previous run) can cause
+ * initPlugins to look for plugin files that no longer exist.
+ *
+ * @param {string} [cwd=process.cwd()] - Working directory to resolve config from
+ * @returns {Promise<boolean>} true if the database was dropped, false otherwise
+ */
+export async function dropTestDb (cwd = process.cwd()) {
+  try {
+    const configPath = path.resolve(cwd, 'conf', `${process.env.NODE_ENV || 'testing'}.config.js`)
+    const config = (await import(configPath)).default
+    const uri = config['adapt-authoring-mongodb']?.connectionUri
+    if (!uri) return false
+    const { MongoClient } = await import('mongodb')
+    const client = new MongoClient(uri)
+    await client.connect()
+    await client.db().dropDatabase()
+    await client.close()
+    return true
+  } catch (e) {
+    // not fatal – the DB may not exist yet on first run
+    return false
+  }
+}

package/lib/fixtures.js

@@ -0,0 +1,136 @@
+import fs from 'fs/promises'
+import os from 'os'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const FIXTURES_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'fixtures')
+
+let manifest
+let resolvedDirs
+let tempDir
+
+/**
+ * Returns the custom fixtures directory path (if CUSTOM_DIR is set).
+ * @returns {string|undefined}
+ */
+function getCustomFixturesDir () {
+  return process.env.CUSTOM_DIR && path.join(process.env.CUSTOM_DIR, 'fixtures')
+}
+
+/**
+ * Reads a manifest.json, returning null if not found.
+ * @param {string} dir - Directory containing the manifest
+ * @returns {Promise<Object|null>}
+ */
+async function readManifest (dir) {
+  try {
+    return JSON.parse(await fs.readFile(path.join(dir, 'manifest.json'), 'utf8'))
+  } catch (e) {
+    if (e.code === 'ENOENT') return null
+    throw e
+  }
+}
+
+/**
+ * Loads and caches the merged manifest from the built-in fixtures directory
+ * and optional custom directory (CUSTOM_DIR/fixtures/).
+ * Custom fixtures override built-in fixtures when keys collide.
+ * @returns {Promise<Object>}
+ */
+export async function getManifest () {
+  if (manifest) return manifest
+
+  const customDir = getCustomFixturesDir()
+
+  const standard = await readManifest(FIXTURES_DIR)
+  const custom = customDir ? await readManifest(customDir) : null
+
+  if (!standard && !custom) {
+    const msg = [
+      `No fixtures manifest found at ${path.join(FIXTURES_DIR, 'manifest.json')}`,
+      '',
+      'To set up fixtures:',
+      '  1. Create a manifest.json in the fixtures directory',
+      '  2. Map fixture names to files, e.g.: { "course-export": "course-export.zip" }',
+      '  3. Place the fixture files alongside the manifest',
+      '',
+      'To provide custom fixtures:',
+      '  CUSTOM_DIR=/path/to/custom npx at-integration-test',
+      '  (expects custom/fixtures/manifest.json)'
+    ].join('\n')
+    throw new Error(msg)
+  }
+
+  manifest = {}
+  resolvedDirs = {}
+
+  if (standard) {
+    for (const [key, file] of Object.entries(standard)) {
+      manifest[key] = file
+      resolvedDirs[key] = FIXTURES_DIR
+    }
+  }
+  if (custom) {
+    for (const [key, file] of Object.entries(custom)) {
+      manifest[key] = file
+      resolvedDirs[key] = customDir
+    }
+  }
+
+  return manifest
+}
+
+/**
+ * Returns a temp directory for fixture copies, creating it on first call.
+ * @returns {Promise<string>}
+ */
+async function getTempDir () {
+  if (!tempDir) {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'aat-fixtures-'))
+  }
+  return tempDir
+}
+
+/**
+ * Resolves a fixture key to an absolute file path.
+ * Copies the fixture to a temp directory so the original is preserved
+ * (the import process may consume/delete the source file).
+ * @param {string} key - Logical fixture name from manifest (e.g. "course-export")
+ * @returns {Promise<string>} Absolute path to the copied fixture file
+ * @throws {Error} If the key is not found in the manifest or the file doesn't exist
+ */
+export async function getFixture (key) {
+  const m = await getManifest()
+  if (!m[key]) {
+    throw new Error(`Fixture "${key}" not found in manifest. Available: ${Object.keys(m).join(', ')}`)
+  }
+  const fixturePath = path.join(resolvedDirs[key], m[key])
+  try {
+    await fs.access(fixturePath)
+  } catch {
+    throw new Error(`Fixture file not found: ${fixturePath}`)
+  }
+  const tmp = await getTempDir()
+  const destPath = path.join(tmp, `${key}-${Date.now()}-${m[key]}`)
+  await fs.copyFile(fixturePath, destPath)
+  return destPath
+}
+
+/**
+ * Resets the cached manifest (useful if switching fixtures mid-test).
+ */
+export function resetManifest () {
+  manifest = undefined
+  resolvedDirs = undefined
+}
+
+/**
+ * Removes the temp directory used for fixture copies.
+ * Call in a global teardown or after() hook if desired.
+ */
+export async function cleanupFixtures () {
+  if (tempDir) {
+    await fs.rm(tempDir, { recursive: true, force: true })
+    tempDir = undefined
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "adapt-authoring-integration-tests",
+  "version": "0.0.1",
+  "description": "Integration test suite for the Adapt authoring tool",
+  "repository": "github:adapt-security/adapt-authoring-integration-tests",
+  "license": "GPL-3.0",
+  "type": "module",
+  "bin": {
+    "at-integration-test": "./bin/run.js"
+  },
+  "devDependencies": {
+    "@semantic-release/git": "^10.0.1",
+    "conventional-changelog-eslint": "^6.0.0",
+    "semantic-release": "^25.0.2",
+    "standard": "^17.1.0"
+  },
+  "release": {
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "eslint"
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "eslint"
+        }
+      ],
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  }
+}

package/tests/adaptframework-build.spec.js

@@ -0,0 +1,120 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs/promises'
+import { getApp, getModule, cleanDb } from '../lib/app.js'
+import { getFixture } from '../lib/fixtures.js'
+
+let framework
+let courseId
+
+describe('AdaptFramework build', () => {
+  before(async () => {
+    await getApp()
+    framework = await getModule('adaptframework')
+    await getModule('content')
+
+    // Import a course to use as build input
+    const fixturePath = await getFixture('course-export')
+    const importer = await framework.importCourse({
+      importPath: fixturePath,
+      userId: '000000000000000000000000',
+      tags: [],
+      importContent: true,
+      importPlugins: true,
+      migrateContent: true,
+      updatePlugins: false,
+      removeSource: false
+    })
+    courseId = importer.summary.courseId.toString()
+  })
+
+  after(async () => {
+    await cleanDb()
+  })
+
+  describe('Export', () => {
+    let buildResult
+
+    it('should export a course without errors', async () => {
+      buildResult = await framework.buildCourse({
+        action: 'export',
+        courseId,
+        userId: '000000000000000000000000'
+      })
+      assert.ok(buildResult, 'build should return a result')
+      assert.ok(buildResult.buildData, 'result should include buildData')
+    })
+
+    it('should have created a build record', async () => {
+      const mongodb = await getModule('mongodb')
+      const [record] = await mongodb.find('adaptbuilds', { _id: buildResult.buildData._id })
+      assert.ok(record, 'build record should exist in database')
+      assert.equal(record.action, 'export')
+      assert.equal(record.courseId.toString(), courseId)
+    })
+
+    it('should have created an output file', async () => {
+      const location = buildResult.buildData.location
+      assert.ok(location, 'buildData should have a location')
+      const stat = await fs.stat(location)
+      assert.ok(stat.size > 0, 'output file should not be empty')
+    })
+
+    it('should have created a zip with substantial content', async () => {
+      const stat = await fs.stat(buildResult.buildData.location)
+      assert.ok(stat.size > 1000, 'export zip should have substantial content')
+    })
+  })
+
+  describe('Preview', () => {
+    let buildResult
+
+    it('should create a preview build without errors', async () => {
+      buildResult = await framework.buildCourse({
+        action: 'preview',
+        courseId,
+        userId: '000000000000000000000000'
+      })
+      assert.ok(buildResult, 'build should return a result')
+      assert.ok(buildResult.buildData, 'result should include buildData')
+      assert.equal(buildResult.isPreview, true, 'should be marked as preview')
+    })
+
+    it('should have created the build output directory', async () => {
+      const location = buildResult.buildData.location
+      assert.ok(location, 'buildData should have a location')
+      const stat = await fs.stat(location)
+      assert.ok(stat.isDirectory(), 'preview output should be a directory')
+    })
+
+    it('should contain index.html', async () => {
+      const indexPath = `${buildResult.buildData.location}/index.html`
+      const stat = await fs.stat(indexPath)
+      assert.ok(stat.size > 0, 'index.html should exist and not be empty')
+    })
+  })
+
+  describe('Publish', () => {
+    let buildResult
+
+    it('should publish a course without errors', async () => {
+      buildResult = await framework.buildCourse({
+        action: 'publish',
+        courseId,
+        userId: '000000000000000000000000'
+      })
+      assert.ok(buildResult, 'build should return a result')
+      assert.ok(buildResult.buildData, 'result should include buildData')
+    })
+
+    it('should have created a zip file', async () => {
+      const location = buildResult.buildData.location
+      const stat = await fs.stat(location)
+      assert.ok(stat.size > 1000, 'publish zip should have substantial content')
+    })
+
+    it('should have recorded build versions', async () => {
+      assert.ok(buildResult.buildData.versions, 'buildData should include versions')
+    })
+  })
+})