@vida-global/core 2.1.1 → 2.2.0

package/test/server/controllerMixins/renderer.test.js

@@ -1,4 +1,5 @@
 const { FooController }        = require('../helpers/controllers/fooController');
+const { buildResponseMock }    = require('../helpers/response');
 const   TestHelpers            = require('@vida-global/test-helpers');
 const {
     NoActiveStreamError,
@@ -76,7 +77,7 @@ describe('VidaServerController', () => {
         const successHandlers = [
             ['renderCreationSuccessful', 201],
             ['renderAccepted',           202],
-            ['renderNoConent',           204],
+            ['renderNoContent',          204],
             ['renderMovedPermanently',   301],
             ['renderFound',              302],
             ['renderNotModified',        304],
@@ -159,7 +160,7 @@ describe('VidaServerController', () => {
         let response;
         let controller;
         beforeEach(() => {
-            response   = {json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), statusCode: 200};
+            response   = buildResponseMock();
             controller = new FooController({}, response);
         });
 
@@ -221,30 +222,34 @@ describe('VidaServerController', () => {
             expect(await controller._serializeResponseBody(true,    {})).toBe(true);
         });
 
-        it ('returns Date instances as their epoch ms via getTime', async () => {
+        it ('returns Date instances as their epoch seconds', async () => {
             const date = new Date('2020-01-02T03:04:05Z');
-            expect(await controller._serializeResponseBody(date, {})).toBe(date.getTime());
+            const seconds = Math.floor(date.getTime() / 1000);
+            expect(await controller._serializeResponseBody(date, {})).toBe(seconds);
         });
 
         it ('recursively processes Date values inside objects', async () => {
             const date = new Date('2021-02-03T00:00:00Z');
+            const seconds = Math.floor(date.getTime() / 1000);
             const result = await controller._serializeResponseBody({createdAt: date, name: 'foo'}, {});
-            expect(result).toEqual({createdAt: date.getTime(), name: 'foo'});
+            expect(result).toEqual({createdAt: seconds, name: 'foo'});
         });
 
         it ('recursively processes arrays', async () => {
             const date = new Date('2022-03-04T00:00:00Z');
+            const seconds = Math.floor(date.getTime() / 1000);
             const result = await controller._serializeResponseBody([1, date, {ts: date}], {});
-            expect(result).toEqual([1, date.getTime(), {ts: date.getTime()}]);
+            expect(result).toEqual([1, seconds, {ts: seconds}]);
         });
 
         it ('invokes toApiResponse on objects that define it and recurses on the result', async () => {
             const date     = new Date('2023-04-05T00:00:00Z');
+            const seconds  = Math.floor(date.getTime() / 1000);
             const apiModel = {
                 async toApiResponse() { return {id: 1, createdAt: date}; }
             };
             const result = await controller._serializeResponseBody(apiModel, {});
-            expect(result).toEqual({id: 1, createdAt: date.getTime()});
+            expect(result).toEqual({id: 1, createdAt: seconds});
         });
 
         it ('passes the options argument through to toApiResponse', async () => {
@@ -278,24 +283,24 @@ describe('VidaServerController', () => {
             expect(controller.requestedFormat).toBe('json');
         });
 
-        it ('returns "xml" when the Accept header requests xml', () => {
+        it ('ignores an xml Accept header and defaults to json', () => {
             const controller = new FooController({headers: {accept: 'application/xml'}}, {});
-            expect(controller.requestedFormat).toBe('xml');
+            expect(controller.requestedFormat).toBe('json');
         });
 
-        it ('lets the _format param override a conflicting Accept header', () => {
+        it ('honors the _format param regardless of the Accept header', () => {
             const controller = new FooController({query: {_format: 'json'}, headers: {accept: 'application/xml'}}, {});
             expect(controller.requestedFormat).toBe('json');
         });
 
-        it ('defaults to json when neither the param nor the header indicate a format', () => {
+        it ('defaults to json when the param does not indicate a format', () => {
             const controller = new FooController({}, {});
             expect(controller.requestedFormat).toBe('json');
         });
 
-        it ('ignores an unrecognized _format and falls back to the Accept header', () => {
+        it ('defaults to json for an unrecognized _format, ignoring the Accept header', () => {
             const controller = new FooController({query: {_format: 'yaml'}, headers: {accept: 'application/xml'}}, {});
-            expect(controller.requestedFormat).toBe('xml');
+            expect(controller.requestedFormat).toBe('json');
         });
     });
 
@@ -329,7 +334,7 @@ describe('VidaServerController', () => {
     describe('#render format dispatch', () => {
         let response;
         beforeEach(() => {
-            response = {json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), statusCode: 200};
+            response = buildResponseMock();
         });
 
         it ('renders JSON via response.json for a JSON request', async () => {
@@ -367,6 +372,18 @@ describe('VidaServerController', () => {
             expect(sent).toContain('<status>ok</status>');
         });
 
+        it ('wraps the body under a custom root element when xmlRootElement is overridden', async () => {
+            class CustomRootController extends FooController {
+                get xmlRootElement() { return 'Response'; }
+            }
+            const controller = new CustomRootController({query: {_format: 'xml'}}, response);
+            await controller.render({foo: 'bar'});
+            const sent = response.send.mock.calls[0][0];
+            expect(sent).toContain('<Response>');
+            expect(sent).toContain('</Response>');
+            expect(sent).not.toContain('<response>');
+        });
+
         it ('renders array items as separate elements instead of concatenated text', async () => {
             const controller = new FooController({query: {_format: 'xml'}}, response);
             await controller.render({tags: ['one', 'two']});
@@ -384,6 +401,49 @@ describe('VidaServerController', () => {
     });
 
 
+    describe('#render content-type', () => {
+        let response;
+        beforeEach(() => {
+            response = buildResponseMock();
+        });
+
+        const defaultTypeCases = [
+            ['JSON', {},                    'application/json; charset=utf-8'],
+            ['XML',  {query: {_format: 'xml'}}, 'application/xml; charset=utf-8'],
+        ];
+        it.each(defaultTypeCases)('sets the default %s content-type when none is set', async (_label, params, expected) => {
+            const controller = new FooController(params, response);
+            await controller.render({foo: 'bar'});
+            expect(response.setHeader).toHaveBeenCalledWith('content-type', expected);
+        });
+
+        it ('sets the default text content-type when none is set for a string body', async () => {
+            const controller = new FooController({}, response);
+            await controller.render('hello');
+            expect(response.setHeader).toHaveBeenCalledWith('content-type', 'text/plain; charset=utf-8');
+        });
+
+
+        const preexistingTypeCases = [
+            ['JSON',   {}],
+            ['XML',    {query: {_format: 'xml'}}],
+            ['string', {}],
+        ];
+        it.each(preexistingTypeCases)('does not override an already-set content-type for a %s render', async (label, params) => {
+            const customType = TestHelpers.Faker.Text.randomString();
+            response.setHeader('content-type', customType);
+            response.setHeader.mockClear();
+
+            const controller = new FooController(params, response);
+            const body        = label === 'string' ? 'hello' : {foo: 'bar'};
+            await controller.render(body);
+
+            expect(response.setHeader).not.toHaveBeenCalledWith('content-type', expect.anything());
+            expect(response.getHeader('content-type')).toBe(customType);
+        });
+    });
+
+
     describe('#_serializeArrayForResponseBody', () => {
         class FakeRecord {
             constructor(id) { this.id = id; }

package/test/server/helpers/response.js

@@ -0,0 +1,19 @@
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+// A response double that keeps a real header store so getHeader reflects what setHeader wrote.
+// This lets tests exercise the renderer's "don't override an already-set content type" logic.
+function buildResponseMock(overrides = {}) {
+    const headers  = {};
+    const response = {
+        json:       jest.fn(),
+        send:       jest.fn(),
+        setHeader:  jest.fn((name, value) => { headers[`${name}`.toLowerCase()] = value; }),
+        getHeader:  jest.fn((name)        => headers[`${name}`.toLowerCase()]),
+        statusCode: 200,
+    };
+    return Object.assign(response, overrides);
+}
+
+
+module.exports = { buildResponseMock };

package/test/server/serverController.test.js

@@ -1,6 +1,7 @@
 const { FooController }        = require('./helpers/controllers/fooController');
 const   Errors                 = require('../../lib/server/errors');
 const { randomPayload }        = require('./helpers/serverController');
+const { buildResponseMock }    = require('./helpers/response');
 const   TestHelpers            = require('@vida-global/test-helpers');
 const {
     VidaServerController,
@@ -338,7 +339,7 @@ describe('VidaServerController', () => {
         });
 
         it ('awaits render before calling response.end (regression: ERR_HTTP_HEADERS_SENT)', async () => {
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new FooController({}, response);
             controller.testAction = jest.fn(async () => ({foo: TestHelpers.Faker.Text.randomString()}));
 
@@ -360,7 +361,7 @@ describe('VidaServerController', () => {
 
         beforeEach(() => {
             request                         = {headers: randomPayload()};
-            response                        = {headers: randomPayload(), statusCode: TestHelpers.Faker.Math.randomNumber(), json: jest.fn(), send: jest.fn(), setHeader: jest.fn()};
+            response                        = buildResponseMock({headers: randomPayload(), statusCode: TestHelpers.Faker.Math.randomNumber()});
             request.headers['content-type'] = TestHelpers.Faker.Text.randomString();
             controller                      = new FooController(request, response);
         });
@@ -524,7 +525,7 @@ describe('VidaServerController', () => {
                 namedBefore() { order.push('before2') }
                 testAction()  { order.push('action');  return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -541,7 +542,7 @@ describe('VidaServerController', () => {
                 namedAfter() { order.push('after2') }
                 testAction() { order.push('action'); return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -554,7 +555,7 @@ describe('VidaServerController', () => {
                 setupCallbacks() { this.beforeCallback(() => false) }
             }
             C.prototype.testAction = testAction;
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -570,7 +571,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');
@@ -586,7 +587,7 @@ describe('VidaServerController', () => {
                 }
                 testAction() { return {} }
             }
-            const response   = { json: jest.fn(), send: jest.fn(), setHeader: jest.fn(), end: jest.fn(), statusCode: 200 };
+            const response   = buildResponseMock({ end: jest.fn() });
             const controller = new C({}, response);
 
             await controller.performRequest('testAction');