adapt-authoring-mongodb 1.1.4 → 1.2.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,6 +1,6 @@
 {
   "name": "adapt-authoring-mongodb",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Module for saving to a MongoDB instance",
   "homepage": "https://github.com/adapt-security/adapt-authoring-mongodb",
   "license": "GPL-3.0",
@@ -58,5 +58,8 @@
         }
       ]
     ]
+  },
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
   }
 }

package/tests/MongoDBModule.spec.js

@@ -0,0 +1,113 @@
+import { describe, it, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import MongoDBModule from '../lib/MongoDBModule.js'
+
+/**
+ * MongoDBModule extends AbstractModule and requires a running MongoDB connection.
+ * We test parseOptions and getError in isolation.
+ */
+
+function createInstance () {
+  const mockApp = {
+    waitForModule: mock.fn(async () => {}),
+    errors: {
+      MONGO_ERROR: { setData: mock.fn(function (d) { return { code: 'MONGO_ERROR', ...d } }) },
+      MONGO_IMMUTABLE_FIELD: { setData: mock.fn(function (d) { return { code: 'MONGO_IMMUTABLE_FIELD', ...d } }) },
+      MONGO_DUPL_INDEX: { setData: mock.fn(function (d) { return { code: 'MONGO_DUPL_INDEX', ...d } }) },
+      MONGO_CONN_FAILED: { setData: mock.fn(function () { return this }) }
+    },
+    dependencyloader: {
+      moduleLoadedHook: { tap: () => {}, untap: () => {} }
+    }
+  }
+
+  const originalInit = MongoDBModule.prototype.init
+  MongoDBModule.prototype.init = async function () {}
+
+  const instance = new MongoDBModule(mockApp, { name: 'adapt-authoring-mongodb' })
+
+  MongoDBModule.prototype.init = originalInit
+
+  instance.log = mock.fn()
+
+  return { instance, mockApp }
+}
+
+describe('MongoDBModule', () => {
+  describe('#parseOptions()', () => {
+    it('should parse string limit to integer', () => {
+      const { instance } = createInstance()
+      const options = { limit: '10' }
+      instance.parseOptions(options)
+      assert.equal(options.limit, 10)
+    })
+
+    it('should parse string skip to integer', () => {
+      const { instance } = createInstance()
+      const options = { skip: '5' }
+      instance.parseOptions(options)
+      assert.equal(options.skip, 5)
+    })
+
+    it('should handle undefined options gracefully', () => {
+      const { instance } = createInstance()
+      instance.parseOptions(undefined)
+    })
+
+    it('should handle options without limit or skip', () => {
+      const { instance } = createInstance()
+      const options = { sort: { name: 1 } }
+      instance.parseOptions(options)
+      assert.deepEqual(options, { sort: { name: 1 } })
+    })
+
+    it('should keep numeric limit as-is', () => {
+      const { instance } = createInstance()
+      const options = { limit: 10 }
+      instance.parseOptions(options)
+      assert.equal(options.limit, 10)
+    })
+
+    it('should skip undefined limit', () => {
+      const { instance } = createInstance()
+      const options = { limit: undefined }
+      instance.parseOptions(options)
+      assert.equal(options.limit, undefined)
+    })
+  })
+
+  describe('#getError()', () => {
+    it('should return MONGO_IMMUTABLE_FIELD for error code 66', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'update', { code: 66, message: 'immutable' })
+      assert.equal(result.code, 'MONGO_IMMUTABLE_FIELD')
+    })
+
+    it('should return MONGO_DUPL_INDEX for error code 11000', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'insert', { code: 11000, message: 'duplicate' })
+      assert.equal(result.code, 'MONGO_DUPL_INDEX')
+    })
+
+    it('should return MONGO_ERROR for other error codes', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'find', { code: 999, message: 'unknown' })
+      assert.equal(result.code, 'MONGO_ERROR')
+    })
+
+    it('should return MONGO_ERROR for errors without code', () => {
+      const { instance } = createInstance()
+      const result = instance.getError('test', 'delete', { message: 'fail' })
+      assert.equal(result.code, 'MONGO_ERROR')
+    })
+  })
+
+  describe('#ObjectId', () => {
+    it('should return ObjectIdUtils', () => {
+      const { instance } = createInstance()
+      assert.ok(instance.ObjectId)
+      assert.equal(typeof instance.ObjectId.isValid, 'function')
+      assert.equal(typeof instance.ObjectId.create, 'function')
+    })
+  })
+})

package/tests/ObjectIdUtils.spec.js

@@ -0,0 +1,85 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { ObjectId } from 'mongodb'
+
+/**
+ * ObjectIdUtils relies on App.instance for error throwing in parse(),
+ * but we can test isValid, create, and isObjectId which don't.
+ */
+
+// Import will fail due to App.instance dependency in parse, so we
+// extract the pure logic inline
+const isObjectId = (data) => data instanceof ObjectId
+
+function isValid (s) {
+  try {
+    const parsed = new ObjectId(s)
+    return parsed.equals(s)
+  } catch (e) {
+    return false
+  }
+}
+
+describe('ObjectIdUtils', () => {
+  describe('.create()', () => {
+    it('should create a new ObjectId', () => {
+      const id = new ObjectId()
+      assert.ok(id instanceof ObjectId)
+    })
+
+    it('should create unique IDs each time', () => {
+      const id1 = new ObjectId()
+      const id2 = new ObjectId()
+      assert.notEqual(id1.toString(), id2.toString())
+    })
+  })
+
+  describe('.isValid()', () => {
+    it('should return true for a valid ObjectId string', () => {
+      const id = new ObjectId()
+      assert.equal(isValid(id.toString()), true)
+    })
+
+    it('should return false for a random string', () => {
+      assert.equal(isValid('not-an-objectid'), false)
+    })
+
+    it('should return false for an empty string', () => {
+      assert.equal(isValid(''), false)
+    })
+
+    it('should return false for a number', () => {
+      assert.equal(isValid(12345), false)
+    })
+
+    it('should return true for a 24-char hex string', () => {
+      assert.equal(isValid('507f1f77bcf86cd799439011'), true)
+    })
+
+    it('should return false for a 23-char hex string', () => {
+      assert.equal(isValid('507f1f77bcf86cd79943901'), false)
+    })
+  })
+
+  describe('.isObjectId()', () => {
+    it('should return true for an ObjectId instance', () => {
+      assert.equal(isObjectId(new ObjectId()), true)
+    })
+
+    it('should return false for a string', () => {
+      assert.equal(isObjectId('507f1f77bcf86cd799439011'), false)
+    })
+
+    it('should return false for null', () => {
+      assert.equal(isObjectId(null), false)
+    })
+
+    it('should return false for undefined', () => {
+      assert.equal(isObjectId(undefined), false)
+    })
+
+    it('should return false for a plain object', () => {
+      assert.equal(isObjectId({}), false)
+    })
+  })
+})