adapt-authoring-server 2.2.3 → 2.2.4

package/lib/ServerUtils.js

@@ -86,6 +86,7 @@ class ServerUtils {
         const e = App.instance.errors[error.code]
         if (e) {
           if (error.statusCode) e.statusCode = error.statusCode
+          if (error.data) e.setData(error.data)
           e.error = error.message
           error = e
         } else {

package/lib/utils/loadRouteConfig.js

@@ -66,7 +66,7 @@ export async function loadRouteConfig (rootDir, target, options = {}) {
     ? resolveHandlers(config.routes, target, aliases)
     : []
 
-  // Prepend default routes from template if provided (unless useDefaultRoutes is false)
+  // Prepend default routes from template if provided
   if (options.defaults && config.useDefaultRoutes !== false) {
     const template = await readJson(options.defaults)
     const defaultRoutes = resolveHandlers(template.routes || [], target, aliases)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-authoring-server",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "description": "Provides an Express application routing and more",
   "homepage": "https://github.com/adapt-security/adapt-authoring-server",
   "license": "GPL-3.0",

package/tests/ServerUtils.spec.js

@@ -17,6 +17,18 @@ describe('ServerUtils', () => {
   })
 
   describe('#addErrorHandler()', () => {
+    /** Set up a res with addErrorHandler + status/json capture */
+    function createSendErrorSetup (reqOverrides = {}) {
+      const req = { translate: (error) => error.message, ...reqOverrides }
+      const res = {}
+      ServerUtils.addErrorHandler(req, res, () => {})
+      let statusCode
+      let jsonData
+      res.status = (code) => { statusCode = code; return res }
+      res.json = (data) => { jsonData = data }
+      return { req, res, getStatus: () => statusCode, getJson: () => jsonData }
+    }
+
     it('should add sendError method to response object', () => {
       const req = {}
       const res = {}
@@ -30,28 +42,18 @@ describe('ServerUtils', () => {
     })
 
     it('sendError should send AdaptError as JSON with status code', () => {
-      const req = { translate: (error) => error.message }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addErrorHandler(req, res, next)
-
-      let statusCode
-      let jsonData
-      res.status = (code) => { statusCode = code; return res }
-      res.json = (data) => { jsonData = data }
+      const { res, getStatus, getJson } = createSendErrorSetup()
 
-      const adaptError = {
+      res.sendError({
         constructor: { name: 'AdaptError' },
         statusCode: 404,
         code: 'NOT_FOUND',
         message: 'Not found'
-      }
-      res.sendError(adaptError)
+      })
 
-      assert.equal(statusCode, 404)
-      assert.equal(jsonData.code, 'NOT_FOUND')
-      assert.equal(jsonData.message, 'Not found')
+      assert.equal(getStatus(), 404)
+      assert.equal(getJson().code, 'NOT_FOUND')
+      assert.equal(getJson().message, 'Not found')
     })
 
     it('sendError should fall back to SERVER_ERROR for unknown errors', () => {
@@ -63,21 +65,12 @@ describe('ServerUtils', () => {
         message: 'Internal server error'
       }
 
-      const req = { translate: (error) => error.message }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addErrorHandler(req, res, next)
-
-      let statusCode
-      let jsonData
-      res.status = (code) => { statusCode = code; return res }
-      res.json = (data) => { jsonData = data }
+      const { res, getStatus, getJson } = createSendErrorSetup()
 
       res.sendError(new Error('something broke'))
 
-      assert.equal(statusCode, 500)
-      assert.equal(jsonData.code, 'SERVER_ERROR')
+      assert.equal(getStatus(), 500)
+      assert.equal(getJson().code, 'SERVER_ERROR')
     })
 
     it('sendError should look up known error codes on non-AdaptError', () => {
@@ -88,68 +81,60 @@ describe('ServerUtils', () => {
         message: 'Custom error'
       }
 
-      const req = { translate: (error) => error.message }
-      const res = {}
-      const next = () => {}
-
-      ServerUtils.addErrorHandler(req, res, next)
-
-      let statusCode
-      let jsonData
-      res.status = (code) => { statusCode = code; return res }
-      res.json = (data) => { jsonData = data }
+      const { res, getStatus, getJson } = createSendErrorSetup()
 
       const error = new Error('details')
       error.code = 'CUSTOM_CODE'
       res.sendError(error)
 
-      assert.equal(statusCode, 422)
-      assert.equal(jsonData.code, 'CUSTOM_CODE')
+      assert.equal(getStatus(), 422)
+      assert.equal(getJson().code, 'CUSTOM_CODE')
     })
 
-    it('sendError should include data field in response', () => {
-      const req = { translate: (error) => error.message }
-      const res = {}
-      const next = () => {}
+    it('sendError should copy data from non-AdaptError to looked-up error', () => {
+      App.instance.errors = App.instance.errors || {}
+      App.instance.errors.VALIDATION_FAILED = {
+        statusCode: 400,
+        code: 'VALIDATION_FAILED',
+        message: 'Validation failed',
+        setData (data) { this.data = data; return this }
+      }
 
-      ServerUtils.addErrorHandler(req, res, next)
+      const { res, getJson } = createSendErrorSetup()
 
-      let jsonData
-      res.status = () => res
-      res.json = (data) => { jsonData = data }
+      const error = new Error('Validation failed')
+      error.code = 'VALIDATION_FAILED'
+      error.data = { errors: '/title is required', schemaName: 'config' }
+      res.sendError(error)
 
-      const adaptError = {
+      assert.deepEqual(getJson().data, { errors: '/title is required', schemaName: 'config' })
+    })
+
+    it('sendError should include data field in response', () => {
+      const { res, getJson } = createSendErrorSetup()
+
+      res.sendError({
         constructor: { name: 'AdaptError' },
         statusCode: 400,
         code: 'BAD_REQUEST',
         message: 'Bad request',
         data: { field: 'email' }
-      }
-      res.sendError(adaptError)
+      })
 
-      assert.deepEqual(jsonData.data, { field: 'email' })
+      assert.deepEqual(getJson().data, { field: 'email' })
     })
 
     it('sendError should use error.message when req.translate is not available', () => {
-      const req = {}
-      const res = {}
-      const next = () => {}
+      const { res, getJson } = createSendErrorSetup({ translate: undefined })
 
-      ServerUtils.addErrorHandler(req, res, next)
-
-      let jsonData
-      res.status = () => res
-      res.json = (data) => { jsonData = data }
-
-      const adaptError = {
+      res.sendError({
         constructor: { name: 'AdaptError' },
         statusCode: 500,
         code: 'ERR',
         message: 'fallback message'
-      }
-      res.sendError(adaptError)
+      })
 
-      assert.equal(jsonData.message, 'fallback message')
+      assert.equal(getJson().message, 'fallback message')
     })
   })