@vida-global/core 1.4.5 → 2.0.0

package/test/server/serverController.test.js

@@ -5,7 +5,11 @@ 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 } = require('../../lib/server');
+const {
+    NoActiveStreamError,
+    StreamInProgressError,
+    VidaServerController
+}                              = require('../../lib/server/serverController');
 
 describe('VidaServerController', () => {
     describe('.actionNames', () => {
@@ -123,6 +127,178 @@ describe('VidaServerController', () => {
     });
 
 
+    describe('#hasParam', () => {
+        let controller;
+        beforeEach(() => {
+            const params = {foo: 'bar', empty: '', falsy: false, nully: null};
+            controller   = new FooController({params}, {});
+        });
+
+        it ('returns true when the named key exists in params', () => {
+            expect(controller.hasParam('foo')).toBe(true);
+        });
+
+        it ('returns true when the value is an empty string', () => {
+            expect(controller.hasParam('empty')).toBe(true);
+        });
+
+        it ('returns true when the value is null', () => {
+            expect(controller.hasParam('nully')).toBe(true);
+        });
+
+        it ('returns true when the value is false', () => {
+            expect(controller.hasParam('falsy')).toBe(true);
+        });
+
+        it ('returns false when the named key is not in params', () => {
+            expect(controller.hasParam('nope')).toBe(false);
+        });
+    });
+
+
+    describe('#coerceBoolean', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns true when passed boolean true', () => {
+            expect(controller.coerceBoolean(true)).toBe(true);
+        });
+
+        it ('returns false when passed boolean false', () => {
+            expect(controller.coerceBoolean(false)).toBe(false);
+        });
+
+        it.each([
+            ['true'],
+            ['TRUE'],
+            ['1'],
+            ['yes'],
+            ['on'],
+            ['  ON  '],
+        ])('coerces "%s" to true', (input) => {
+            expect(controller.coerceBoolean(input)).toBe(true);
+        });
+
+        it.each([
+            ['false'],
+            ['FALSE'],
+            ['0'],
+            ['no'],
+            ['off'],
+            ['  off  '],
+        ])('coerces "%s" to false', (input) => {
+            expect(controller.coerceBoolean(input)).toBe(false);
+        });
+
+        it ('returns the fallback for an unrecognized string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean('maybe', {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for an empty/whitespace string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean('   ', {fallback})).toBe(fallback);
+        });
+
+        it.each([
+            [null],
+            [undefined],
+            [123],
+            [{}],
+            [[]],
+        ])('returns the fallback for non-string, non-boolean input (%p)', (input) => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean(input, {fallback})).toBe(fallback);
+        });
+
+        it ('defaults the fallback to undefined when no options are given', () => {
+            expect(controller.coerceBoolean('maybe')).toBe(undefined);
+        });
+    });
+
+
+    describe('#coerceInteger', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns the fallback for null', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(null, {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for undefined', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(undefined, {fallback})).toBe(fallback);
+        });
+
+        it.each([
+            [''],
+            ['   '],
+        ])('returns the fallback for empty/whitespace string (%p)', (input) => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(input, {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for a non-numeric string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger('abc', {fallback})).toBe(fallback);
+        });
+
+        it ('parses an integer string to an integer', () => {
+            expect(controller.coerceInteger('42')).toBe(42);
+        });
+
+        it ('floors a decimal string value', () => {
+            expect(controller.coerceInteger('3.7')).toBe(3);
+        });
+
+        it ('accepts an integer value directly', () => {
+            expect(controller.coerceInteger(42)).toBe(42);
+        });
+
+        it ('floors a decimal numeric value', () => {
+            expect(controller.coerceInteger(3.7)).toBe(3);
+        });
+
+        it ('clamps to min when the value is below min', () => {
+            expect(controller.coerceInteger(1, {min: 5})).toBe(5);
+        });
+
+        it ('clamps to max when the value is above max', () => {
+            expect(controller.coerceInteger(100, {max: 50})).toBe(50);
+        });
+
+        it ('returns the fallback when nonNegative is set and the value is negative', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(-3, {nonNegative: true, fallback})).toBe(fallback);
+        });
+    });
+
+
+    describe('#coerceObject', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns a plain object unchanged', () => {
+            const input = {foo: TestHelpers.Faker.Text.randomString()};
+            expect(controller.coerceObject(input)).toBe(input);
+        });
+
+        it.each([
+            [null],
+            [undefined],
+            [[1, 2]],
+            ['string'],
+            [42],
+            [true],
+        ])('returns the fallback for non-plain-object input (%p)', (input) => {
+            const fallback = {foo: TestHelpers.Faker.Text.randomString()};
+            expect(controller.coerceObject(input, {fallback})).toBe(fallback);
+        });
+
+        it ('defaults the fallback to an empty object', () => {
+            expect(controller.coerceObject(null)).toEqual({});
+        });
+    });
+
+
     describe('.validateParameters', () => {
         const paramName1      = TestHelpers.Faker.Text.randomString();
         const paramName2      = TestHelpers.Faker.Text.randomString();
@@ -444,6 +620,35 @@ describe('VidaServerController', () => {
     });
 
 
+    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();
@@ -494,8 +699,6 @@ describe('VidaServerController', () => {
             const body       = {[key]: value};
             const message    = TestHelpers.Faker.Text.randomString();
 
-          if (!Errors[errorClsName]) console.log(errorClsName);
-
             const error      = new Errors[errorClsName](message, body);
             if (handlerName == 'renderErrors') error.errors = randomPayload();
 
@@ -708,8 +911,15 @@ describe('VidaServerController', () => {
 
 
         describe('#logger', () => {
-            it ('uses the standard logger', () => {
-                expect(controller.logger).toBe(logger);
+            it ('returns a child of the passed logger, scoped to the request id', () => {
+                const childLogger  = {};
+                const passedLogger = { child: jest.fn(() => childLogger) };
+                request.id         = TestHelpers.Faker.Text.randomString();
+
+                const c = new FooController(request, response, passedLogger);
+
+                expect(passedLogger.child).toHaveBeenCalledWith(request.id);
+                expect(c.logger).toBe(childLogger);
             });
         });
 
@@ -762,4 +972,196 @@ describe('VidaServerController', () => {
 
     describe('Request Properties', () => {
     });
+
+
+    describe('#statusText', () => {
+        const cases = [
+            [200, 'ok'],
+            [201, 'created'],
+            [202, 'accepted'],
+            [204, 'no content'],
+            [301, 'moved permanently'],
+            [302, 'found'],
+            [304, 'not modified'],
+            [307, 'temporary redirect'],
+            [308, 'permanent redirect'],
+            [400, 'bad request'],
+            [401, 'unauthorized'],
+            [402, 'payment required'],
+            [403, 'forbidden'],
+            [404, 'not found'],
+            [405, 'method not allowed'],
+            [408, 'request timeout'],
+            [409, 'conflict'],
+            [410, 'gone'],
+            [413, 'content too large'],
+            [415, 'unsupported media type'],
+            [422, 'unprocessable content'],
+            [423, 'locked'],
+            [429, 'too many requests'],
+            [500, 'server error'],
+            [501, 'not implemented'],
+            [502, 'bad gateway'],
+            [503, 'service unavailable'],
+            [504, 'gateway timeout'],
+        ];
+
+        it.each(cases)('returns "%s" text for status %s', (statusCode, expected) => {
+            const controller = new FooController({}, { statusCode });
+            expect(controller.statusText).toEqual(expected);
+        });
+
+        it ('returns undefined for an unmapped status code', () => {
+            const controller = new FooController({}, { statusCode: 418 });
+            expect(controller.statusText).toBeUndefined();
+        });
+    });
+
+
+    describe('#streamSseResponse', () => {
+        let controller;
+        let response;
+        let request;
+        let setHeaderSpy;
+
+        beforeEach(() => {
+            request          = { on: jest.fn(), off: jest.fn() };
+            response         = {
+                setHeader:     jest.fn(),
+                flushHeaders:  jest.fn(),
+                write:         jest.fn(),
+                end:           jest.fn(),
+                writableEnded: false
+            };
+            controller       = new FooController(request, response);
+            setHeaderSpy     = response.setHeader;
+        });
+
+        it ('sets SSE headers, flushes them, and marks rendered before invoking handler', async () => {
+            const handler = jest.fn(async function () {
+                expect(this).toBe(controller);
+                expect(controller.rendered).toBe(true);
+                expect(setHeaderSpy).toHaveBeenCalledWith('Content-Type',      'text/event-stream; charset=utf-8');
+                expect(setHeaderSpy).toHaveBeenCalledWith('Cache-Control',     'no-cache');
+                expect(setHeaderSpy).toHaveBeenCalledWith('Connection',        'keep-alive');
+                expect(setHeaderSpy).toHaveBeenCalledWith('X-Accel-Buffering', 'no');
+                expect(response.flushHeaders).toHaveBeenCalledTimes(1);
+                expect(controller.statusCode).toBe(200);
+            });
+            await controller.streamSseResponse(handler, jest.fn());
+            expect(handler).toHaveBeenCalledTimes(1);
+        });
+
+        it ('writes [DONE] and ends the response in the finally block', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            expect(response.write).toHaveBeenLastCalledWith('data: [DONE]\n\n');
+            expect(response.end).toHaveBeenCalledTimes(1);
+        });
+
+        it ('throws StreamInProgressError when called while already streaming', async () => {
+            await controller.streamSseResponse(async () => {
+                await expect(controller.streamSseResponse(jest.fn(), jest.fn()))
+                    .rejects.toBeInstanceOf(StreamInProgressError);
+            }, jest.fn());
+        });
+
+        it ('invokes errorHandler and rethrows when handler throws', async () => {
+            const err          = new Error('boom');
+            const handler      = jest.fn(async () => { throw err; });
+            const errorHandler = jest.fn();
+            await expect(controller.streamSseResponse(handler, errorHandler)).rejects.toThrow('boom');
+            expect(errorHandler).toHaveBeenCalledWith(err);
+        });
+
+        it ('still ends the response when handler throws', async () => {
+            const errorHandler = jest.fn();
+            await expect(controller.streamSseResponse(
+                async () => { throw new Error('boom'); },
+                errorHandler
+            )).rejects.toThrow();
+            expect(response.end).toHaveBeenCalledTimes(1);
+        });
+
+        it ('wires close listener to abortController when one is provided', async () => {
+            const abortController = { abort: jest.fn() };
+            await controller.streamSseResponse(jest.fn(), jest.fn(), abortController);
+            expect(request.on).toHaveBeenCalledWith('close', expect.any(Function));
+            expect(request.off).toHaveBeenCalledWith('close', expect.any(Function));
+            // The handler registered on 'close' should call abort.
+            const closeHandler = request.on.mock.calls.find(c => c[0] === 'close')[1];
+            closeHandler();
+            expect(abortController.abort).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not register a close listener when no abortController is provided', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            expect(request.on).not.toHaveBeenCalled();
+            expect(request.off).not.toHaveBeenCalled();
+        });
+
+        it ('resets streaming state after completion so a new stream can start', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            // Second call should not throw StreamInProgressError.
+            await expect(controller.streamSseResponse(jest.fn(), jest.fn())).resolves.toBeUndefined();
+        });
+    });
+
+
+    describe('#writeStreamEvent', () => {
+        let controller;
+        let response;
+
+        beforeEach(() => {
+            response   = {
+                setHeader:     jest.fn(),
+                flushHeaders:  jest.fn(),
+                write:         jest.fn(),
+                end:           jest.fn(),
+                writableEnded: false
+            };
+            controller = new FooController({ on: jest.fn(), off: jest.fn() }, response);
+        });
+
+        it ('throws NoActiveStreamError when called outside a stream', () => {
+            expect(() => controller.writeStreamEvent('msg', 'hello'))
+                .toThrow(NoActiveStreamError);
+        });
+
+        it ('writes both event and data lines when an event name is provided', async () => {
+            await controller.streamSseResponse(async () => {
+                response.write.mockClear();
+                controller.writeStreamEvent('progress', 'halfway');
+                expect(response.write).toHaveBeenNthCalledWith(1, 'event: progress\n');
+                expect(response.write).toHaveBeenNthCalledWith(2, 'data: halfway\n\n');
+            }, jest.fn());
+        });
+
+        it ('writes only the data line when no event name is provided', async () => {
+            await controller.streamSseResponse(async () => {
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'plain');
+                expect(response.write).toHaveBeenCalledTimes(1);
+                expect(response.write).toHaveBeenCalledWith('data: plain\n\n');
+            }, jest.fn());
+        });
+
+        it ('is a no-op when the response is already ended', async () => {
+            await controller.streamSseResponse(async () => {
+                response.writableEnded = true;
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'ignored');
+                expect(response.write).not.toHaveBeenCalled();
+            }, jest.fn());
+        });
+
+        it ('is a no-op when the abort signal is aborted', async () => {
+            const abortController = { abort: jest.fn(), signal: { aborted: false } };
+            await controller.streamSseResponse(async () => {
+                abortController.signal.aborted = true;
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'ignored');
+                expect(response.write).not.toHaveBeenCalled();
+            }, jest.fn(), abortController);
+        });
+    });
 });