@vida-global/core 2.0.10 → 2.1.0

package/test/server/serverController.test.js

@@ -1,32 +1,14 @@
-const { BarController }        = require('./helpers/controllers/barController');
 const { FooController }        = require('./helpers/controllers/fooController');
-const { camelize }             = require('inflection');
 const   Errors                 = require('../../lib/server/errors');
-const { logger }               = require('../../lib/logger');
 const { randomPayload }        = require('./helpers/serverController');
 const   TestHelpers            = require('@vida-global/test-helpers');
 const {
+    VidaServerController,
     NoActiveStreamError,
     StreamInProgressError,
-    VidaServerController
 }                              = require('../../lib/server/serverController');
 
 describe('VidaServerController', () => {
-    describe('.actionNames', () => {
-        it ('returns actions based on method names', () => {
-            const names      = FooController.actionNames;
-            const expected   = ['postIndex',
-                                'getFooBar',
-                                'getBazBan',
-                                'postFooBar',
-                                'putFooBar',
-                                'deleteFooBar',
-                                'patchFooBar'];
-            expect(names).toEqual(expected);
-        });
-    });
-
-
     describe('.autoLoadMixins', () => {
         class AutoLoadTestController extends VidaServerController {
             static get mixinDirectory() {
@@ -78,69 +60,6 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('._constructAction', () => {
-        class UsersController extends VidaServerController {
-            static get routes() {
-                return {getBazBan: '/baz/:id/ban'};
-            }
-        };
-
-        it ('returns an object with path, method, and action', () => {
-            const expected   = {
-              method: 'GET',
-              path:   '/users/fooBar',
-              action: 'getFooBar'
-            }
-            expect(UsersController._constructAction('getFooBar', '')).toEqual(expected);
-        });
-
-        it ('uses a blank path for index actions', () => {
-            const expected   = {
-              method: 'POST',
-              path:   '/users',
-              action: 'postIndex'
-            }
-            expect(UsersController._constructAction('postIndex', '')).toEqual(expected);
-        });
-
-        it ('creates a single resource route for Record', () => {
-            const expected   = {
-              method: 'GET',
-              path:   '/user/:id',
-              action: 'getRecord'
-            }
-            expect(UsersController._constructAction('getRecord', '')).toEqual(expected);
-        });
-
-        it ('only uses Record when checking for single resource routes', () => {
-            const expected   = {
-              method: 'GET',
-              path:   '/users/recording',
-              action: 'getRecording'
-            }
-            expect(UsersController._constructAction('getRecording', '')).toEqual(expected);
-        });
-
-        it ('creates a single sub resource route for RecordFoo', () => {
-            const expected   = {
-              method: 'GET',
-              path:   '/user/:id/foo',
-              action: 'getRecordFoo'
-            }
-            expect(UsersController._constructAction('getRecordFoo', '')).toEqual(expected);
-        });
-
-        it ('uses a custom path when defined', () => {
-            const expected   = {
-              method: 'GET',
-              path:   '/baz/:id/ban',
-              action: 'getBazBan'
-            }
-            expect(UsersController._constructAction('getBazBan', '')).toEqual(expected);
-        });
-    });
-
-
     describe('#hasParam', () => {
         let controller;
         beforeEach(() => {
@@ -359,452 +278,6 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('.validateParameters', () => {
-        const paramName1      = TestHelpers.Faker.Text.randomString();
-        const paramName2      = TestHelpers.Faker.Text.randomString();
-        const value1          = TestHelpers.Faker.Text.randomString();
-        const value2          = TestHelpers.Faker.Text.randomString();
-        const validationType1 = TestHelpers.Faker.Text.randomString();
-        const validationType2 = TestHelpers.Faker.Text.randomString();
-        const options1        = [TestHelpers.Faker.Text.randomString()];
-        const options2        = [TestHelpers.Faker.Text.randomString()];
-        const error1          = TestHelpers.Faker.Text.randomString()
-        const error2          = TestHelpers.Faker.Text.randomString()
-
-        let params;
-        let controller;
-        let response;
-        let validator1;
-        let validator2;
-        beforeEach(() => {
-            params                                             = {[paramName1]: value1, [paramName2]: value2};
-            response                                           = {json: jest.fn(), statusCode: 200};
-            controller                                         = new FooController({params}, response);
-            controller.render                                  = jest.fn();
-            validator1                                         = jest.fn();
-            validator2                                         = jest.fn();
-            controller[`validate${camelize(validationType1)}`] = validator1;
-            controller[`validate${camelize(validationType2)}`] = validator2;
-        });
-
-        const validations = {
-            [paramName1]: {[validationType1]: options1, [validationType2]: options2},
-            [paramName2]: {[validationType1]: options2}
-        };
-
-        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);
-
-            expect(validator2).toHaveBeenCalledTimes(1);
-            expect(validator2).toHaveBeenCalledWith(value1, options2);
-        });
-
-        it ('throws a `ValidationError` when there\'s an error', async () => {
-            validator1.mockImplementation(() => error1);
-            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
-        });
-
-        it ('attaches the failing parameter and error message to the ValidationError fields', async () => {
-            validator1.mockImplementation(() => error1);
-            await expect(controller.validateParameters(validations)).rejects.toMatchObject({
-                fields: {[paramName1]: [error1], [paramName2]: [error1]}
-            });
-        });
-
-        it ('throws a `ValidationError` when there are multiple errors', async () => {
-            validator1.mockImplementation(() => error1);
-            validator2.mockImplementation(() => error2);
-
-            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
-        });
-
-        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', async () => {
-            const validations = {
-                [paramName2]: {[validationType1]: options2, 'foo': true}
-            };
-            await controller.validateParameters(validations);
-
-            expect(validator1).toHaveBeenCalledTimes(1);
-            expect(validator1).toHaveBeenCalledWith(value2, options2);
-        });
-
-        it ('does not error when optional parameters are not included', async () => {
-            const validations = {foo: {isString: true, optional: true}};
-            await expect(controller.validateParameters(validations)).resolves.not.toThrow();
-        });
-
-        it ('does error when optional parameters are invalid', async () => {
-            const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
-            params.foo = '';
-
-            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
-        });
-    });
-
-
-    describe('.validateAction', () => {
-        it ('is a no-op when the controller has no parametersFor<Action> method', async () => {
-            class C extends VidaServerController {}
-            const controller = new C({}, {});
-            controller.validateParameters = jest.fn();
-
-            await controller.validateAction('getThing');
-            expect(controller.validateParameters).not.toHaveBeenCalled();
-        });
-
-        it ('calls validateParameters with the value returned by parametersFor<Action>', async () => {
-            const params = {foo: {isString: true}};
-            class C extends VidaServerController {
-                static parametersForGetThing() { return params; }
-            }
-            const controller = new C({}, {});
-            controller.validateParameters = jest.fn();
-
-            await controller.validateAction('getThing');
-            expect(controller.validateParameters).toHaveBeenCalledTimes(1);
-            expect(controller.validateParameters).toHaveBeenCalledWith(params);
-        });
-
-        it ('camelizes the action name when looking up the parametersFor method', async () => {
-            const params = {foo: {isString: true}};
-            class C extends VidaServerController {
-                static parametersForGetFooBar() { return params; }
-            }
-            const controller = new C({}, {});
-            controller.validateParameters = jest.fn();
-
-            await controller.validateAction('getFooBar');
-            expect(controller.validateParameters).toHaveBeenCalledWith(params);
-        });
-
-        it ('propagates ValidationError thrown by validateParameters', async () => {
-            class C extends VidaServerController {
-                static parametersForGetThing() { return {foo: {isString: true}}; }
-            }
-            const request = { params: {}, query: {}, body: {foo: 42} };
-            const controller = new C(request, {});
-
-            await expect(controller.validateAction('getThing')).rejects.toThrow(Errors.ValidationError);
-        });
-    });
-
-
-    describe('.parametersForAction', () => {
-        it ('returns null when no parametersFor method is defined', () => {
-            class C extends VidaServerController {}
-            expect(C.parametersForAction('getThing')).toBe(null);
-        });
-
-        it ('returns the value of the matching parametersFor<Action> method', () => {
-            const params = {foo: {isString: true}};
-            class C extends VidaServerController {
-                static parametersForGetThing() { return params; }
-            }
-            expect(C.parametersForAction('getThing')).toBe(params);
-        });
-    });
-
-
-    describe('.parametersMethodForAction', () => {
-        it ('returns the camelized parametersFor<Action> method name', () => {
-            class C extends VidaServerController {}
-            expect(C.parametersMethodForAction('getFooBar')).toBe('parametersForGetFooBar');
-            expect(C.parametersMethodForAction('postIndex')).toBe('parametersForPostIndex');
-        });
-    });
-
-
-    describe('.validatePresence', () => {
-        const controller = new FooController({}, {});
-        it ('returns undefined when there is a value', () => {
-            const result = controller.validatePresence(TestHelpers.Faker.Text.randomString());
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns an error when there is no value', () => {
-            const result = controller.validatePresence();
-            expect(result).toEqual('required');
-        });
-    });
-
-
-    describe('.validateIsInteger', () => {
-        const controller = new FooController({}, {});
-        it ('returns undefined when there is an integer', () => {
-            const val    = Math.ceil(Math.random() * 100);
-            const result = controller.validateIsInteger(val)
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns undefined when there is an integer string', () => {
-            const val    = Math.ceil(Math.random() * 100).toString();
-            const result = controller.validateIsInteger(val)
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns an error when there is a non integer number', () => {
-            const val    = Math.random() * 100;
-            const result = controller.validateIsInteger(val)
-            expect(result).toEqual('must be an integer');
-        });
-
-        it ('returns an error when there is a non integer string', () => {
-            // starts with a number because parseFloat converts a string to a float if it starts with a number
-            const val    = '1' + TestHelpers.Faker.Text.randomString();
-            const result = controller.validateIsInteger(val)
-            expect(result).toEqual('must be an integer');
-        });
-
-        it ('returns an error when the value is null', () => {
-            const result = controller.validateIsInteger(null)
-            expect(result).toEqual('must be an integer');
-        });
-
-        it ('returns an error when the value is undefined', () => {
-            const result = controller.validateIsInteger(undefined)
-            expect(result).toEqual('must be an integer');
-        });
-
-        it ('returns an error when the value is an object', () => {
-            const result = controller.validateIsInteger({})
-            expect(result).toEqual('must be an integer');
-        });
-
-        it ('returns an error when the number is less than the gte option', () => {
-            const result = controller.validateIsInteger(1, {gte: 2});
-            expect(result).toEqual('must be greater than or equal to 2');
-        });
-
-        it ('returns undefined when the number is greater than the gte option', () => {
-            const result = controller.validateIsInteger(3, {gte: 2});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns undefined when the number is equal to the gte option', () => {
-            const result = controller.validateIsInteger(2, {gte: 2});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns an error when the number is greater than the lte option', () => {
-            const result = controller.validateIsInteger(3, {lte: 2});
-            expect(result).toEqual('must be less than or equal to 2');
-        });
-
-        it ('returns undefined when the number is less than the lte option', () => {
-            const result = controller.validateIsInteger(1, {lte: 2});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns undefined when the number is equal to the lte option', () => {
-            const result = controller.validateIsInteger(2, {lte: 2});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('supports both the lte and gte options', () => {
-            let result = controller.validateIsInteger(1, {lte: 2, gte: 0});
-            expect(result).toEqual(undefined);
-
-            result = controller.validateIsInteger(-1, {lte: 2, gte: 0});
-            expect(result).toEqual('must be greater than or equal to 0');
-
-            result = controller.validateIsInteger(3, {lte: 2, gte: 0});
-            expect(result).toEqual('must be less than or equal to 2');
-        });
-    });
-
-
-    describe('.validateIsString', () => {
-        const controller = new FooController({}, {});
-        it ('returns undefined when there is an string', () => {
-            const result = controller.validateIsString('')
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns an error when there is a number', () => {
-            const result = controller.validateIsString(Math.random());
-            expect(result).toEqual('must be a string');
-        });
-
-        it ('returns an error when the value is null', () => {
-            const result = controller.validateIsString(null)
-            expect(result).toEqual('must be a string');
-        });
-
-        it ('returns an error when the value is undefined', () => {
-            const result = controller.validateIsString(undefined)
-            expect(result).toEqual('must be a string');
-        });
-
-        it ('returns an error when the value is an object', () => {
-            const result = controller.validateIsString({})
-            expect(result).toEqual('must be a string');
-        });
-
-        it ('returns an error when the length is fewer than the gte option', () => {
-            const result = controller.validateIsString('f', {length: {gte: 2}});
-            expect(result).toEqual('must be greater than or equal to 2 characters');
-        });
-
-        it ('returns undefined when the length is greater than the gte option', () => {
-            const result = controller.validateIsString('foo', {length: {gte: 2}});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns undefined when the length is equal to the gte option', () => {
-            const result = controller.validateIsString('fo', {length: {gte: 2}});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns an error when the length is greater than the lte option', () => {
-            const result = controller.validateIsString('foo', {length: {lte: 2}});
-            expect(result).toEqual('must be fewer than or equal to 2 characters');
-        });
-
-        it ('returns undefined when the length is fewer than the lte option', () => {
-            const result = controller.validateIsString('f', {length: {lte: 2}});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('returns undefined when the length is equal to the lte option', () => {
-            const result = controller.validateIsString('fo', {length: {lte: 2}});
-            expect(result).toEqual(undefined);
-        });
-
-        it ('supports both the lte and gte options', () => {
-            let result = controller.validateIsString('fo', {length: {lte: 3, gte: 1}});
-            expect(result).toEqual(undefined);
-
-            result = controller.validateIsString('', {length: {lte: 3, gte: 1}});
-            expect(result).toEqual('must be greater than or equal to 1 characters');
-
-            result = controller.validateIsString('foobar', {length: {lte: 3, gte: 1}});
-            expect(result).toEqual('must be fewer than or equal to 3 characters');
-        });
-
-        it ('returns undefined when the value matches the pattern', () => {
-            const result = controller.validateIsString('foo', {regex: /oo/})
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns an error when the value does not match the pattern', () => {
-            const result = controller.validateIsString('bar', {regex: /oo/})
-            expect(result).toBe(`must match /oo/`);
-        });
-    });
-
-
-    describe('.validateIsDateTime', () => {
-        const controller = new FooController({}, {});
-        it ('returns undefined when passed a date string of format YYYY-MM-DD', () => {
-            const result = controller.validateIsDateTime('2025-12-17');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns undefined when passed a date string of format MM/DD/YY', () => {
-            const result = controller.validateIsDateTime('12/17/25');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns undefined when passed a date string of format Month name DD, YYYY', () => {
-            const result = controller.validateIsDateTime('December 17, 2025');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns undefined when passed a datetime string of format YYYY-MM-DD HH:MM:SS', () => {
-            const result = controller.validateIsDateTime('2025-12-17 01:05:00');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns undefined when passed a datetime string of format MM/DD/YY HH:MM:SS', () => {
-            const result = controller.validateIsDateTime('12/17/25 01:05:00');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns undefined when passed a datetime string of format Month name DD, YYYY HH:MM:SS', () => {
-            const result = controller.validateIsDateTime('December 17, 2025 01:05:00');
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns an error when passed an invalid date', () => {
-            const result = controller.validateIsDateTime('foo');
-            expect(result).toEqual('invalid date');
-        });
-    });
-
-
-    describe('.validateIsEnum', () => {
-        const controller = new FooController({}, {});
-        const enums      = [Math.random(), Math.random(), Math.random()];
-        const error      = TestHelpers.Faker.Text.randomString();
-        const options    = { enums, error }
-        it ('returns undefined when passed a valid value', () => {
-            const result = controller.validateIsEnum(enums[2], options);
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns an error when passed an invalid date', () => {
-            const result = controller.validateIsEnum('foo', options);
-            expect(result).toBe(error);
-        });
-    });
-
-
-    describe('.validateIsBoolean', () => {
-        const controller = new FooController({}, {});
-        it ('returns undefined when passed a matching boolean', () => {
-            const result1 = controller.validateIsBoolean(true, true);
-            const result2 = controller.validateIsBoolean(false, false);
-            expect(result1).toBe(undefined);
-            expect(result2).toBe(undefined);
-        });
-
-        it ('returns an error when passed an non matching boolean', () => {
-            const result1 = controller.validateIsBoolean(true, false);
-            const result2 = controller.validateIsBoolean(false, true);
-            expect(result1).toBe('must be false');
-            expect(result2).toBe('must be true');
-        });
-
-        it ('returns an error when passed an non boolean', () => {
-            const result1 = controller.validateIsBoolean('', false);
-            const result2 = controller.validateIsBoolean(0, false);
-            const result3 = controller.validateIsBoolean('foo', true);
-            const result4 = controller.validateIsBoolean(1, true);
-            expect(result1).toBe('must be false');
-            expect(result2).toBe('must be false');
-            expect(result3).toBe('must be true');
-            expect(result4).toBe('must be true');
-        });
-    });
-
-
-    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 undefined 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', async () => {
-            const result = await controller.validateFunction(Math.random(), validator);
-            expect(result).toBe(error);
-        });
-    });
-
-
     describe('#performRequest', () => {
         const errorHandlers = [
             ['renderUnauthorized',         'AuthorizationError'],
@@ -865,7 +338,7 @@ describe('VidaServerController', () => {
         });
 
         it ('awaits render before calling response.end (regression: ERR_HTTP_HEADERS_SENT)', async () => {
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new FooController({}, response);
             controller.testAction = jest.fn(async () => ({foo: TestHelpers.Faker.Text.randomString()}));
 
@@ -880,266 +353,6 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('Rendering', () => {
-        let controller;
-        let response;
-        beforeEach(() => {
-            response          = {json: jest.fn(), statusCode: 200};
-            controller        = new FooController({}, response);
-            controller.render = jest.fn();
-        });
-
-        describe('#renderErrors', () => {
-            it ('returns a 400 response', async () => {
-                await controller.renderErrors();
-                expect(response.statusCode).toBe(400);
-            })
-
-            it ('includes a blank message and blank fields by default', async () => {
-                await controller.renderErrors();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {}}});
-            })
-
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderErrors(msg);
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg, fields: {}}});
-            });
-
-            it ('includes provided field data', async () => {
-                const field1 = TestHelpers.Faker.Text.randomString();
-                const msg1   = TestHelpers.Faker.Text.randomString();
-                const msg2   = TestHelpers.Faker.Text.randomString();
-                await controller.renderErrors(null, {[field1]: [msg1, msg2]});
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1, msg2]}}});
-            });
-
-            it ('includes provided message field data', async () => {
-                const field1 = TestHelpers.Faker.Text.randomString();
-                const msg1   = TestHelpers.Faker.Text.randomString();
-                const msg2   = TestHelpers.Faker.Text.randomString();
-                const msg3   = TestHelpers.Faker.Text.randomString();
-                await controller.renderErrors(msg1, {[field1]: [msg2, msg3]});
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg1, fields: {[field1]: [msg2, msg3]}}});
-            });
-
-            it ('uses the first parameter as fields if it is an object', async () => {
-                const field1 = TestHelpers.Faker.Text.randomString();
-                const msg1   = TestHelpers.Faker.Text.randomString();
-                const msg2   = TestHelpers.Faker.Text.randomString();
-                await controller.renderErrors({[field1]: [msg1, msg2]});
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1, msg2]}}});
-            });
-
-            it ('converts single field error messages to arrays', async () => {
-                const field1 = TestHelpers.Faker.Text.randomString();
-                const msg1   = TestHelpers.Faker.Text.randomString();
-                await controller.renderErrors({[field1]: msg1});
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1]}}});
-            });
-        });
-
-
-        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 the provided body', async () => {
-                const key   = TestHelpers.Faker.Text.randomString();
-                const value = TestHelpers.Faker.Text.randomString();
-                const body  = {[key]: value};
-                await (controller[handlerName](body));
-
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                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],
-            ['renderServerError',          500],
-            ['renderNotImplemented',       501],
-            ['renderBadGateway',           502],
-            ['renderServiceUnavailable',   503],
-            ['renderGatewayTimeout',       504],
-        ]
-
-        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[handlerName]();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
-            })
-
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller[handlerName](msg);
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
-            });
-
-            it ('includes a provided body and message', async () => {
-                const key      = TestHelpers.Faker.Text.randomString();
-                const val      = TestHelpers.Faker.Text.randomString();
-                const body     = {[key]: val};
-                const msg      = TestHelpers.Faker.Text.randomString();
-                const expected = {...body, errors: {message: msg}};
-                await controller[handlerName](msg, body);
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith(expected);
-            });
-        });
-    });
-
-
-    describe('#render', () => {
-        let response;
-        let controller;
-        beforeEach(() => {
-            response   = {json: jest.fn(), send: jest.fn(), statusCode: 200};
-            controller = new FooController({}, response);
-        });
-
-        it ('calls response.send (not response.json) when the body is a string', async () => {
-            const body = TestHelpers.Faker.Text.randomString();
-            await controller.render(body);
-
-            expect(response.send).toHaveBeenCalledTimes(1);
-            expect(response.send).toHaveBeenCalledWith(body);
-            expect(response.json).not.toHaveBeenCalled();
-        });
-
-        it ('marks the controller as rendered after a string render', async () => {
-            await controller.render('hello');
-            expect(controller.rendered).toBe(true);
-        });
-
-        it ('is a no-op when the controller has already been rendered', async () => {
-            controller.markRendered();
-            await controller.render('hello');
-            expect(response.send).not.toHaveBeenCalled();
-            expect(response.json).not.toHaveBeenCalled();
-        });
-
-        it ('is a no-op when the controller is streaming', async () => {
-            controller._isStreaming = true;
-            await controller.render('hello');
-            await controller.render({foo: 'bar'});
-
-            expect(response.send).not.toHaveBeenCalled();
-            expect(response.json).not.toHaveBeenCalled();
-        });
-
-        it ('does not mark the controller as rendered when streaming', async () => {
-            controller._isStreaming = true;
-            await controller.render('hello');
-            expect(controller.rendered).toBe(false);
-        });
-    });
-
-
-    describe('#processJSONBody', () => {
-        let controller;
-        beforeEach(() => {
-            controller = new FooController({}, {});
-        });
-
-        it ('returns null when the body is undefined', async () => {
-            expect(await controller.processJSONBody(undefined, {})).toBe(null);
-        });
-
-        it ('returns null when the body is null', async () => {
-            expect(await controller.processJSONBody(null, {})).toBe(null);
-        });
-
-        it ('returns primitives unchanged', async () => {
-            expect(await controller.processJSONBody('hello', {})).toBe('hello');
-            expect(await controller.processJSONBody(42,      {})).toBe(42);
-            expect(await controller.processJSONBody(true,    {})).toBe(true);
-        });
-
-        it ('returns Date instances as their epoch ms via getTime', async () => {
-            const date = new Date('2020-01-02T03:04:05Z');
-            expect(await controller.processJSONBody(date, {})).toBe(date.getTime());
-        });
-
-        it ('recursively processes Date values inside objects', async () => {
-            const date = new Date('2021-02-03T00:00:00Z');
-            const result = await controller.processJSONBody({createdAt: date, name: 'foo'}, {});
-            expect(result).toEqual({createdAt: date.getTime(), name: 'foo'});
-        });
-
-        it ('recursively processes arrays', async () => {
-            const date = new Date('2022-03-04T00:00:00Z');
-            const result = await controller.processJSONBody([1, date, {ts: date}], {});
-            expect(result).toEqual([1, date.getTime(), {ts: date.getTime()}]);
-        });
-
-        it ('invokes toApiResponse on objects that define it and recurses on the result', async () => {
-            const date     = new Date('2023-04-05T00:00:00Z');
-            const apiModel = {
-                async toApiResponse() { return {id: 1, createdAt: date}; }
-            };
-            const result = await controller.processJSONBody(apiModel, {});
-            expect(result).toEqual({id: 1, createdAt: date.getTime()});
-        });
-
-        it ('passes the options argument through to toApiResponse', async () => {
-            const options    = {standardize: false, extra: 'flag'};
-            const toApi      = jest.fn().mockResolvedValue({});
-            const apiModel   = {toApiResponse: toApi};
-
-            await controller.processJSONBody(apiModel, options);
-            expect(toApi).toHaveBeenCalledWith(options);
-        });
-
-        it ('recurses through arrays of objects with toApiResponse', async () => {
-            const apiModels = [
-                {toApiResponse: async () => ({id: 'a'})},
-                {toApiResponse: async () => ({id: 'b'})},
-            ];
-            const result = await controller.processJSONBody(apiModels, {});
-            expect(result).toEqual([{id: 'a'}, {id: 'b'}]);
-        });
-    });
-
-
     describe('Request Properties', () => {
         let request;
         let response;
@@ -1147,83 +360,11 @@ describe('VidaServerController', () => {
 
         beforeEach(() => {
             request                         = {headers: randomPayload()};
-            response                        = {headers: randomPayload(), statusCode: TestHelpers.Faker.Math.randomNumber(), json: jest.fn()};
+            response                        = {headers: randomPayload(), statusCode: TestHelpers.Faker.Math.randomNumber(), json: jest.fn(), send: jest.fn(), setHeader: jest.fn()};
             request.headers['content-type'] = TestHelpers.Faker.Text.randomString();
             controller                      = new FooController(request, response);
         });
 
-        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));
-            });
-        });
-
-
-        describe('#responseHeaders', () => {
-            it ('returns the request headers', () => {
-                expect(controller.responseHeaders).toBe(response.headers);
-            });
-        });
-
-
-        describe('#contentType', () => {
-            it ('returns the content-type request header', () => {
-                expect(controller.contentType).toEqual(request.headers['content-type']);
-            });
-        });
-
-
-        describe('#userAgent', () => {
-            it ('returns the user-agent request header', () => {
-                const ua = TestHelpers.Faker.Text.randomString();
-                request.headers['user-agent'] = ua;
-                expect(controller.userAgent).toEqual(ua);
-            });
-        });
-
-
-        describe('#requestBody', () => {
-            it ('returns the underlying request body', () => {
-                const body = {foo: TestHelpers.Faker.Text.randomString()};
-                request.body = body;
-                expect(controller.requestBody).toBe(body);
-            });
-        });
-
-
-        describe('#requestId', () => {
-            it ('returns the request id', () => {
-                request.id = TestHelpers.Faker.Text.randomString();
-                expect(controller.requestId).toEqual(request.id);
-            });
-        });
-
-
-        describe('#requestIp', () => {
-            it ('returns the request ip', () => {
-                request.ip = TestHelpers.Faker.Text.randomString();
-                expect(controller.requestIp).toEqual(request.ip);
-            });
-        });
-
-
-        describe('#requestMethod', () => {
-            it ('returns the request method', () => {
-                request.method = 'POST';
-                expect(controller.requestMethod).toEqual('POST');
-            });
-        });
-
-
-        describe('#url', () => {
-            it ('returns the request originalUrl', () => {
-                request.originalUrl = `/${TestHelpers.Faker.Text.randomString()}`;
-                expect(controller.url).toEqual(request.originalUrl);
-            });
-        });
-
-
         describe('#logger', () => {
             it ('returns a child of the passed logger, scoped to the request id', () => {
                 const childLogger  = {};
@@ -1383,7 +524,7 @@ describe('VidaServerController', () => {
                 namedBefore() { order.push('before2') }
                 testAction()  { order.push('action');  return {} }
             }
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -1400,7 +541,7 @@ describe('VidaServerController', () => {
                 namedAfter() { order.push('after2') }
                 testAction() { order.push('action'); return {} }
             }
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -1413,7 +554,7 @@ describe('VidaServerController', () => {
                 setupCallbacks() { this.beforeCallback(() => false) }
             }
             C.prototype.testAction = testAction;
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -1429,7 +570,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -1445,7 +586,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');