@vida-global/core 1.3.2 → 1.4.0

package/.github/workflows/npm-publish.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
           registry-url: 'https://registry.npmjs.org'
 
       - name: Update npm

package/.github/workflows/npm-test.yml

@@ -16,7 +16,7 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '24'
           registry-url: 'https://registry.npmjs.org'
 
       - name: Install dependencies

package/lib/logger/index.js

@@ -1,7 +1,10 @@
 const pino = require('pino');
 
 const config = {
-    level: process.env.LOG_LEVEL || 'info'
+    level: process.env.LOG_LEVEL || 'info',
+    customLevels: {
+      test: 1000
+    }
 };
 
 if (!process.env.ENV_VERCEL) {

package/lib/server/README.md

@@ -118,9 +118,34 @@ Additional options can be passed to `toApiResponse` by explicitly calling `rende
 await this.render(response, {includeTitle: true});
 ```
 
+### Other Status Codes
+There is no need to set `statusCode` directly as there are helper methods for all statuses.
+```
+201 - this.renderCreationSuccessful
+202 - this.renderAccepted
+204 - this.renderNoConent
+301 - this.renderMovedPermanently
+302 - this.renderFound
+304 - this.renderNotModified
+307 - this.renderTemporaryRedirect
+308 - this.renderPermanentRedirect
+401 - this.renderUnauthorizedResponse
+402 - this.renderPaymentRequired
+403 - this.renderForbiddenResponse
+404 - this.renderNotFoundResponse
+405 - this.renderMethodNotAllowed
+408 - this.renderRequestTimeout
+409 - this.renderConflictResponse
+410 - this.renderGone
+413 - this.renderContentTooLarge
+415 - this.renderUnsupportedMediaType
+422 - this.renderUnprocessableContent
+423 - this.renderLocked
+429 - this.renderTooManyRequests
+```
+
 
 ## Error handling
-There is no need to set `statusCode` directly as there are helper methods for all statuses.
 HTTP 400
 ```
 await this.renderErrors("Something bad happened", {password: ['must be > 8 characters', 'must include numbers']})
@@ -134,19 +159,16 @@ await this.renderErrors({password: ['must be > 8 characters', 'must include numb
 ```
 HTTP 401
 ```
-await this.renderUnauthorizedResponse("Nope")
+await this.renderUnauthorized("Nope")
 // renders {data: {message: "Nope"}, status: "unauthorized"}
 ```
 HTTP 403
 ```
-await this.renderForbiddenResponse("You shall not pass")
+await this.renderForbidden("You shall not pass")
 // renders {data: {message: "You shall not pass"}, status: "forbidden"}
 ```
-HTTP 404
-```
-await this.renderNotFoundResponse("Whoops")
-// renders {data: {message: "Whoops"}, status: "not found"}
-```
+* _Other statuses detailed above._
+
 Throwing any of `this.Errors.Authorization(msg)`, `this.Errors.Forbidden(msg)`, `this.Errors.NotFound(msg)`, `this.Errors.Validation(msg, errors)` from anywhere in the code will trigger the corresponding error handler. All other errors will generate a 500 error.
 
 

package/lib/server/server.js

@@ -106,40 +106,17 @@ class VidaServer {
 
     get loggingMiddleware() {
         return httpLogger({
-            logger: this.middlewareLogger,
-            customLogLevel: (res, err) => {
-                if (res.statusCode >= 500) return 'error';
-                if (res.statusCode >= 400) return 'warn';
-                return 'info';
-            },
-            serializers: {
-                // Format the request log as a string
-                req: (req) => `Request: ${req.method} ${req.url}`,
-                // Format the response log as a string
-                res: (res) => `statusCode=${res.statusCode}, responseTime=${res.get('X-Response-Time')}`,
-            },
-            wrapSerializers: false,
+            logger:               this.middlewareLogger,
+            customLogLevel:       this.requestLogLevel.bind(this),
+            customSuccessMessage: this.requestLogMessage.bind(this),
+            customErrorMessage:   this.requestLogMessage.bind(this),
+            customErrorObject:    this.requestLogDetails.bind(this),
+            customSuccessObject:  this.requestLogDetails.bind(this),
+            wrapSerializers:      false,
         })
     }
 
 
-    get middlewareLogger() {
-      return pino({
-            level: process.env.HTTP_LOG_LEVEL || 'info',
-            transport: {
-                level: process.env.HTTP_LOG_LEVEL || 'info',
-                target: 'pino-pretty',
-                options: {
-                    colorize: true,
-                    ignore: 'pid,hostname',
-                    translateTime: 'SYS:standard',
-                    messageFormat: '{msg}',
-                }
-            },
-        });
-    }
-
-
     get staticFilesDirectory() {
         return `${process.cwd()}/static`;
     }
@@ -158,6 +135,53 @@ class VidaServer {
     use() { this.#expressServer.use(...arguments); }
 
 
+    /***********************************************************************************************
+    * LOGGING
+    ***********************************************************************************************/
+    requestLogDetails(req, res, err) {
+        const details = {
+            req: `${req.method} ${req.url}`,
+            res: `statusCode=${res.statusCode}, responseTime=${res.get('X-Response-Time')}`,
+        };
+
+        if (res.statusCode >= 500 && res.error) {
+            details.error = this.requestLogErrorDetails(req, res, res.error);
+        }
+
+        return details;
+    }
+
+
+    requestLogErrorDetails(req, res, err) {
+        if (typeof err == 'string') return {message: err};
+        return {
+            type: err.constructor.name,
+            message: err.message,
+            stack: err.stack
+        }
+    }
+
+    
+    requestLogMessage(req, res) {
+        const prefix = '[VidaServer]';
+        if (req.controller) {
+            return `${prefix} ${req.controller.constructor.name}#${req.action}`;
+        }
+
+        return `${prefix} ${res.status >= 500 ? 'request errored' : 'request completed'}`;
+    }
+
+
+    requestLogLevel(req, res) {
+        return 'debug';
+    }
+
+
+    get middlewareLogger() {
+        return logger;
+    }
+
+
     /***********************************************************************************************
     * SETTINGS
     ***********************************************************************************************/
@@ -226,8 +250,9 @@ class VidaServer {
 
     requestHandler(action, controllerCls) {
         return async function(request, response) {
-            if (process.env.NODE_ENV != 'test') this.logger.info(`${controllerCls.name}#${action}`);
             const controllerInstance = this.buildController(controllerCls, request, response);
+            request.controller       = controllerInstance;
+            request.action           = action;
             await controllerInstance.performRequest(action);
         }.bind(this);
     }

package/lib/server/serverController.js

@@ -28,6 +28,7 @@ class VidaServerController {
         this.#response = response;
 
         this.#applyCallbacks();
+        this.#setupStatusRenderers();
     }
 
 
@@ -121,21 +122,26 @@ class VidaServerController {
 
     async #handleError(err) {
         if (err instanceof AuthorizationError) {
-            await this.renderUnauthorizedResponse(err.message);
+            await this.renderUnauthorized(err.message);
 
         } else if (err instanceof ForbiddenError) {
-            await this.renderForbiddenResponse(err.message);
+            await this.renderForbidden(err.message);
 
         } else if (err instanceof NotFoundError) {
-            await this.renderNotFoundResponse(err.message);
+            await this.renderNotFound(err.message);
 
         } else if (err instanceof ValidationError) {
             await this.renderErrors(err.message, err.fields);
 
         } else {
-            this.statusCode = 500;
-            await this.render({error: err.message});
-            if (process.env.NODE_ENV == 'development') console.log(err);
+            this._response.error = err;
+            let message;
+            if (typeof err == 'string') {
+                message = err;
+            } else {
+                message = err.message;
+            }
+            await this.renderServerError(message);
         }
     }
 
@@ -148,7 +154,11 @@ class VidaServerController {
             this._response.send(body);
         } else {
             body = await this.processJSONBody(body, options);
-            body = this.formatJSONBody(body, options);
+
+            const  errors = body.errors || null;
+            delete body.errors;
+
+            body = this.formatJSONBody(body, errors, options);
             this._response.json(body);
         }
         this.#rendered = true;
@@ -177,27 +187,21 @@ class VidaServerController {
     }
 
 
-    async renderNotFoundResponse(message=null) {
-        this.statusCode = 404;
-        await this.render({ message });
-    }
-
-
-    async renderUnauthorizedResponse(message=null) {
-        this.statusCode = 401;
-        await this.render({ message });
+    async renderServerError(message=null) {
+        if (process.env.NODE_ENV != 'development') {
+            message = null;
+        }
+        return await this.#renderError(500, message);
     }
 
 
-    async renderForbiddenResponse(message=null) {
-        this.statusCode = 403;
-        await this.render({ message });
-    }
+    formatJSONBody(body, errors, options) {
+        if (options.standardize === false) return body;
 
+        const response = {data: body, status: this.statusText};
+        if (errors) response.errors = errors;
 
-    formatJSONBody(body, options) {
-        if (options.standardize === false) return body;
-        return {data: body, status: this.statusText};
+        return response;
     }
 
 
@@ -231,26 +235,118 @@ class VidaServerController {
         switch(this.statusCode) {
             case 200:
                 return 'ok';
+            case 201:
+                return 'created';
+            case 202:
+                return 'accepted';
+            case 204:
+                return 'no content';
+            case 301:
+              return 'moved permanently';
+            case 302:
+              return 'found';
+            case 304:
+              return 'not modified';
+            case 307:
+              return 'temporary redirect';
+            case 308:
+              return 'permanent redirect';
             case 400:
                 return 'bad request'
             case 401:
                 return 'unauthorized';
+            case 402:
+                return 'payment required';
             case 403:
                 return 'forbidden';
             case 404:
                 return 'not found';
+            case 405:
+                return 'method not allowed';
+            case 408:
+                return 'request timeout';
+            case 409:
+                return 'conflict';
+            case 410:
+                return 'gone';
+            case 413:
+                return 'content too large';
+            case 415:
+                return 'unsupported media type';
+            case 422:
+                return 'unprocessable content';
+            case 423:
+                return 'locked';
+            case 429:
+                return 'too many requests';
             case 500:
                 return 'server error';
         }
     }
 
 
+    #setupStatusRenderers() {
+      const errorStatuses = {
+        Unauthorized:         401,
+        PaymentRequired:      402,
+        Forbidden:            403,
+        NotFound:             404,
+        MethodNotAllowed:     405,
+        RequestTimeout:       408,
+        Conflict:             409,
+        Gone:                 410,
+        ContentTooLarge:      413,
+        UnsupportedMediaType: 415,
+        UnprocessableContent: 422,
+        Locked:               423,
+        TooManyRequests:      429,
+       }
+
+      const successStatuses = {
+        CreationSuccessful: 201,
+        Accepted:           202,
+        NoConent:           204,
+        MovedPermanently:   301,
+        Found:              302,
+        NotModified:        304,
+        TemporaryRedirect:  307,
+        PermanentRedirect:  308,
+      }
+
+      for (const [method, statusCode] of Object.entries(errorStatuses)) {
+        this[`render${method}`] = async function(message=null) {
+            return await this.#renderError(statusCode, message);
+        }
+      }
+
+      for (const [method, statusCode] of Object.entries(successStatuses)) {
+        this[`render${method}`] = async function(message=null) {
+            return await this.#renderSuccess(statusCode, message);
+        }
+      }
+    }
+
+
+    async #renderError(statusCode, message) {
+        this.statusCode = statusCode;
+        const body = {errors: {message: message || null}};
+        return await this.render(body);
+    }
+
+
+    async #renderSuccess(statusCode, body) {
+      this.statusCode = statusCode;
+      return await this.render(body);
+    }
+
+
     /***********************************************************************************************
     * HELPERS
     ***********************************************************************************************/
     static autoLoadHelpers() {
-        const { InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
+        const { StaticMethods, InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
 
+        if (StaticMethods)   Object.assign(this, StaticMethods);
         if (InstanceMethods) Object.assign(this.prototype, InstanceMethods);
 
         if (Accessors) {
@@ -363,10 +459,10 @@ class VidaServerController {
     /***********************************************************************************************
     * VALIDATIONS
     ***********************************************************************************************/
-    validateParameters(validations) {
+    async validateParameters(validations) {
         const errors = {};
         for (const [parameterName, parameterValidations] of Object.entries(validations)) {
-            const parameterErrors = this.validateParameter(this.params[parameterName], parameterValidations);
+            const parameterErrors = await this.validateParameter(this.params[parameterName], parameterValidations);
             if (parameterErrors.length) errors[parameterName] = parameterErrors;
         }
 
@@ -374,7 +470,7 @@ class VidaServerController {
     }
 
 
-    validateParameter(value, parameterValidations) {
+    async validateParameter(value, parameterValidations) {
         const errors = [];
 
         if (parameterValidations?.optional && value === undefined) return errors;
@@ -382,7 +478,7 @@ class VidaServerController {
         for (const [validationType, validationOptions] of Object.entries(parameterValidations)) {
             const validationMethod = `validate${camelize(validationType)}`;
             if (!this[validationMethod]) continue;
-            const error = this[validationMethod](value, validationOptions);
+            const error = await this[validationMethod](value, validationOptions);
             if (error) errors.push(error);
         }
 
@@ -435,8 +531,8 @@ class VidaServerController {
     }
 
 
-    validateFunction(value, fnc) {
-        const error = fnc(value);
+    async validateFunction(value, fnc) {
+        const error = await fnc.call(this, value);
         if (error) return error;
     }
 

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@vida-global/core",
-    "version": "1.3.2",
+    "version": "1.4.0",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",
     "main": "index.js",
     "scripts": {
-        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
+        "test": "LOG_LEVEL=test NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
         "release": "node node_modules/@vida-global/release/scripts/release.js",
         "develop": "node node_modules/@vida-global/release/scripts/release.js develop"
     },
@@ -33,7 +33,7 @@
         "@vida-global/release": "^1.0.0"
     },
     "devDependencies": {
-        "jest": "^30.0.0",
+        "jest": "^29.0.0",
         "jest-express": "^1.12.0",
         "jest-extended": "^7.0.0",
         "@vida-global/test-helpers": "^1.0.1"

package/test/server/server.test.js

@@ -8,7 +8,7 @@ const { VidaServer }    = require('../../lib/server');
 
 
 jest.mock('express', () => {
-    const express      = require('jest-express');
+    const   express    = require('jest-express');
     const { Response } = require('jest-express/lib/response');
 
     // missing functions in mock express

package/test/server/serverController.test.js

@@ -8,7 +8,7 @@ const   TestHelpers            = require('@vida-global/test-helpers');
 const { VidaServerController } = require('../../lib/server');
 
 describe('VidaServerController', () => {
-    describe('VidaServerController.actionNames', () => {
+    describe('.actionNames', () => {
         it ('returns actions based on method names', () => {
             const names      = FooController.actionNames;
             const expected   = ['postIndex',
@@ -23,7 +23,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.autoLoadHelpers', () => {
+    describe('.autoLoadHelpers', () => {
         class AutoLoadTestController extends VidaServerController {
             static get autoLoadHelperPath() {
                 return `${process.cwd()}/test/server/helpers/autoload/${this.name}.js`;
@@ -60,7 +60,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController._constructAction', () => {
+    describe('._constructAction', () => {
         class UsersController extends VidaServerController {
             static get routes() {
                 return {getBazBan: '/baz/:id/ban'};
@@ -123,7 +123,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateParameters', () => {
+    describe('.validateParameters', () => {
         const paramName1      = TestHelpers.Faker.Text.randomString();
         const paramName2      = TestHelpers.Faker.Text.randomString();
         const value1          = TestHelpers.Faker.Text.randomString();
@@ -155,8 +155,8 @@ describe('VidaServerController', () => {
             [paramName2]: {[validationType1]: options2}
         };
 
-        it ('runs validation checkers based on inputs', () => {
-            controller.validateParameters(validations);
+        it ('runs validation checkers based on inputs', async () => {
+            await controller.validateParameters(validations);
             expect(validator1).toHaveBeenCalledTimes(2);
             expect(validator1).toHaveBeenCalledWith(value1, options1);
             expect(validator1).toHaveBeenCalledWith(value2, options2);
@@ -165,59 +165,51 @@ describe('VidaServerController', () => {
             expect(validator2).toHaveBeenCalledWith(value1, options2);
         });
 
-        it ('throws a `ValidationError` when there\'s an error', () => {
+        it ('throws a `ValidationError` when there\'s an error', async () => {
             validator1.mockImplementation(() => error1);
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow();
         });
 
-        it ('throws a `ValidationError` when there are multiple errors', () => {
+        it ('throws a `ValidationError` when there are multiple errors', async () => {
             validator1.mockImplementation(() => error1);
             validator2.mockImplementation(() => error2);
 
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
         });
 
-        it ('sets nothing when there is no error', () => {
-            controller.validateParameters(validations);
+        it ('sets nothing when there is no error', async () => {
+            await controller.validateParameters(validations);
             expect(controller.render).toHaveBeenCalledTimes(0);
             expect(response.statusCode).toEqual(200);
         });
 
-        it ('ignores details where there is no validator', () => {
+        it ('ignores details where there is no validator', async () => {
             const validations = {
                 [paramName2]: {[validationType1]: options2, 'foo': true}
             };
-            controller.validateParameters(validations);
+            await controller.validateParameters(validations);
 
             expect(validator1).toHaveBeenCalledTimes(1);
             expect(validator1).toHaveBeenCalledWith(value2, options2);
         });
 
-        it ('does not error when optional parameters are not included', () => {
+        it ('does not error when optional parameters are not included', async () => {
             const validations = {foo: {isString: true, optional: true}};
-            expect(() => {
-                controller.validateParameters(validations);
-            }).not.toThrow();
+            expect(controller.validateParameters(validations)).resolves.not.toThrow();
         });
 
-        it ('does  error when optional parameters are invalid', () => {
+        it ('does  error when optional parameters are invalid', async () => {
             const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
             params.foo = '';
 
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
 
             delete params.foo;
         });
     });
 
 
-    describe('VidaServerController.validatePresence', () => {
+    describe('.validatePresence', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when there is a value', () => {
             const result = controller.validatePresence(TestHelpers.Faker.Text.randomString());
@@ -231,7 +223,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsInteger', () => {
+    describe('.validateIsInteger', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when there is an integer', () => {
             const val    = Math.ceil(Math.random() * 100);
@@ -316,7 +308,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsString', () => {
+    describe('.validateIsString', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when there is an string', () => {
             const result = controller.validateIsString('')
@@ -396,7 +388,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsDateTime', () => {
+    describe('.validateIsDateTime', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when passed a string of format YYYY-MM-DD', () => {
             const result = controller.validateIsDateTime('2025-12-17');
@@ -435,7 +427,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsEnum', () => {
+    describe('.validateIsEnum', () => {
         const controller = new FooController({}, {});
         const enums      = [Math.random(), Math.random(), Math.random()];
         const error      = TestHelpers.Faker.Text.randomString();
@@ -452,30 +444,30 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateFunction', () => {
+    describe('.validateFunction', () => {
         const controller   = new FooController({}, {});
         const correctValue = Math.random();
         const error        = TestHelpers.Faker.Text.randomString();
         const validator    = (value) => value == correctValue ? undefined : error;
 
-        it ('returns undefiend when passed a valid value', () => {
-            const result = controller.validateFunction(correctValue, validator);
+        it ('returns undefiend when passed a valid value', async () => {
+            const result = await controller.validateFunction(correctValue, validator);
             expect(result).toBe(undefined);
         });
 
-        it ('returns an error when the function returns an error', () => {
-            const result = controller.validateFunction(Math.random(), validator);
+        it ('returns an error when the function returns an error', async () => {
+            const result = await controller.validateFunction(Math.random(), validator);
             expect(result).toBe(error);
         });
     });
 
 
-    describe('VidaServerController#performRequest', () => {
+    describe('#performRequest', () => {
         const errorHandlers = [
-            ['renderUnauthorizedResponse', 'AuthorizationError'],
-            ['renderForbiddenResponse',    'ForbiddenError'],
-            ['renderNotFoundResponse',     'NotFoundError'],
-            ['renderErrors',               'ValidationError'],
+            ['renderUnauthorized', 'AuthorizationError'],
+            ['renderForbidden',    'ForbiddenError'],
+            ['renderNotFound',     'NotFoundError'],
+            ['renderErrors',       'ValidationError'],
         ]
 
         it.each(errorHandlers)('calls %s when %s is thrown', async (handlerName, errorClsName) => {
@@ -505,7 +497,7 @@ describe('VidaServerController', () => {
             await controller.performRequest('testAction');
 
             expect(controller.statusCode).toEqual(500);
-            expect(controller.render).toHaveBeenCalledWith({error: message});
+            expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
         });
     });
 
@@ -519,8 +511,7 @@ describe('VidaServerController', () => {
             controller.render = jest.fn();
         });
 
-        
-        describe('VidaServerController#renderErrors', () => {
+        describe('#renderErrors', () => {
             it ('returns a 400 response', async () => {
                 await controller.renderErrors();
                 expect(response.statusCode).toBe(400);
@@ -576,66 +567,68 @@ describe('VidaServerController', () => {
             });
         });
 
-        
-        describe('VidaServerController#renderUnauthorizedResponse', () => {
-            it ('returns a 401 response', async () => {
-                await controller.renderUnauthorizedResponse();
-                expect(response.statusCode).toBe(401);
-            })
-
-            it ('includes a blank message by default', async () => {
-                await controller.renderUnauthorizedResponse();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
-            })
 
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderUnauthorizedResponse(msg);
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: msg});
-            });
-        });
-
-        
-        describe('VidaServerController#renderForbiddenResponse', () => {
-            it ('returns a 403 response', async () => {
-                await controller.renderForbiddenResponse();
-                expect(response.statusCode).toBe(403);
+        const successHandlers = [
+            ['renderCreationSuccessful', 201],
+            ['renderAccepted',           202],
+            ['renderNoConent',           204],
+            ['renderMovedPermanently',   301],
+            ['renderFound',              302],
+            ['renderNotModified',        304],
+            ['renderTemporaryRedirect',  307],
+            ['renderPermanentRedirect',  308],
+        ]
+        describe.each(successHandlers)('#%s', (handlerName, statusCode) => {
+            it (`returns a ${statusCode} response`, async () => {
+                await (controller[handlerName]());
+                expect(response.statusCode).toBe(statusCode);
             })
 
-            it ('includes a blank message by default', async () => {
-                await controller.renderForbiddenResponse();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
-            })
+            it ('includes the provided body', async () => {
+                const key   = TestHelpers.Faker.Text.randomString();
+                const value = TestHelpers.Faker.Text.randomString();
+                const body  = {[key]: value};
+                await (controller[handlerName](body));
 
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderForbiddenResponse(msg);
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: msg});
+                expect(controller.render).toHaveBeenCalledWith(body);
             });
         });
 
+        
+        const errorHandlers = [
+            ['renderUnauthorized',         401],
+            ['renderPaymentRequired',      402],
+            ['renderForbidden',            403],
+            ['renderNotFound',             404],
+            ['renderMethodNotAllowed',     405],
+            ['renderRequestTimeout',       408],
+            ['renderConflict',             409],
+            ['renderGone',                 410],
+            ['renderContentTooLarge',      413],
+            ['renderUnsupportedMediaType', 415],
+            ['renderUnprocessableContent', 422],
+            ['renderLocked',               423],
+            ['renderTooManyRequests',      429],
+        ]
 
-        describe('VidaServerController#renderNotFoundResponse', () => {
-            it ('returns a 404 response', async () => {
-                await controller.renderNotFoundResponse();
-                expect(response.statusCode).toBe(404);
+        describe.each(errorHandlers)('#%s', (handlerName, statusCode) => {
+            it (`returns a ${statusCode} response`, async () => {
+                await (controller[handlerName]());
+                expect(response.statusCode).toBe(statusCode);
             })
 
             it ('includes a blank message by default', async () => {
-                await controller.renderNotFoundResponse();
+                await controller[handlerName]();
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
             })
 
             it ('includes a provided message', async () => {
                 const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderNotFoundResponse(msg);
+                await controller[handlerName](msg);
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: msg});
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });
         });
     });
@@ -653,7 +646,7 @@ describe('VidaServerController', () => {
             controller                      = new FooController(request, response);
         });
 
-        describe('VidaServerController#requestHeaders', () => {
+        describe('#requestHeaders', () => {
             it ('returns a copy of the request headers', () => {
                 expect(controller.requestHeaders).not.toBe(request.headers);
                 expect(JSON.stringify(controller.requestHeaders)).toEqual(JSON.stringify(request.headers));
@@ -661,28 +654,28 @@ describe('VidaServerController', () => {
         });
 
 
-        describe('VidaServerController#responseHeaders', () => {
+        describe('#responseHeaders', () => {
             it ('returns the request headers', () => {
                 expect(controller.responseHeaders).toBe(response.headers);
             });
         });
 
 
-        describe('VidaServerController#contentType', () => {
+        describe('#contentType', () => {
             it ('returns the content-type request header', () => {
                 expect(controller.contentType).toEqual(request.headers['content-type']);
             });
         });
 
 
-        describe('VidaServerController#logger', () => {
+        describe('#logger', () => {
             it ('uses the standard logger', () => {
                 expect(controller.logger).toBe(logger);
             });
         });
 
 
-        describe('VidaServerController#rendered', () => {
+        describe('#rendered', () => {
             it ('returns false if nothing has rendered', () => {
                 expect(controller.rendered).toBeFalsy();
             });
@@ -701,7 +694,7 @@ describe('VidaServerController', () => {
         });
 
 
-        describe('VidaServerController#statusCode', () => {
+        describe('#statusCode', () => {
             it ('returns the response status code', () => {
                 expect(controller.statusCode).toEqual(response.statusCode);
             });
@@ -715,7 +708,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('ServerController#setupCallbacks', () => {
+    describe('#setupCallbacks', () => {
         it ('is only called once', () => {
             class CallbacksTestController extends VidaServerController {}
             CallbacksTestController.prototype.setupCallbacks = jest.fn();